// xxatomic internal header
// NOTE: no include guard

// Defines struct _ATOMIC_ITYPE, an atomic struct that manages objects
// of type _ITYPE whose size is _ISIZE bytes. Also defines the non-member
// and member functions for atomic operations on _ATOMIC_TYPE.
//
// Used by header <atomic> to define atomic types for integral types and
// addresses.

// Every occurrence of __declspec(nothrow) in this file is TRANSITION, VSO#174686

static_assert(_ISIZE == sizeof (_ITYPE),
	"_ISIZE and _ITYPE should match.");

#define _ATOMIC_UINT _CONCAT(_CONCAT(_Uint, _ISIZE), _t)
#define _ATOMIC_LOCK_FREE_PRIMITIVE_NAME(name)	\
	_CONCAT(name, _ISIZE)
#define _ATOMIC_LOCKING_PRIMITIVE_NAME(name)	\
	_CONCAT(_CONCAT(name, _ISIZE), _locking)

  #define _ATOMIC_STORE(_Atom, _Value, _Order)	\
	_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_store_)\
		((_ATOMIC_UINT*)&_Atom->_My_val,	\
		(_ATOMIC_UINT)_Value, _Order)

  #define _ATOMIC_LOAD(_Atom, _Order)	\
	(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_load_)	\
	((_ATOMIC_UINT*)&_Atom->_My_val, _Order)

  #define _ATOMIC_EXCHANGE(_Atom, _Value, _Order)	\
	(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_exchange_)	\
	((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

  #define _ATOMIC_COMPARE_EXCHANGE_WEAK(_Atom, _Expected, _Desired,\
	_Order1, _Order2)	\
	_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_compare_exchange_weak_)	\
	((_ATOMIC_UINT*)&_Atom->_My_val,	\
		(_ATOMIC_UINT*)_Expected, (_ATOMIC_UINT)_Value,	\
		_Order1, _Order2)

  #define _ATOMIC_COMPARE_EXCHANGE_STRONG(_Atom, _Expected, _Desired,\
	_Order1, _Order2)	\
	_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_compare_exchange_strong_)	\
	((_ATOMIC_UINT*)&_Atom->_My_val,	\
		(_ATOMIC_UINT*)_Expected, (_ATOMIC_UINT)_Value,	\
		_Order1, _Order2)

  #define _ATOMIC_FETCH_ADD(_Atom, _Value, _Order)	\
	(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_add_)	\
	((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

  #define _ATOMIC_FETCH_SUB(_Atom, _Value, _Order)	\
	(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_sub_)	\
	((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

  #define _ATOMIC_FETCH_AND(_Atom, _Value, _Order)	\
	(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_and_)	\
	((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

  #define _ATOMIC_FETCH_OR(_Atom, _Value, _Order)	\
	(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_or_)	\
	((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

  #define _ATOMIC_FETCH_XOR(_Atom, _Value, _Order)	\
	(_ITYPE)_ATOMIC_LOCK_FREE_PRIMITIVE_NAME(_Atomic_fetch_xor_)	\
	((_ATOMIC_UINT*)&_Atom->_My_val, (_ATOMIC_UINT)_Value, _Order)

		// STRUCT _ATOMIC_ITYPE
typedef struct _ATOMIC_ITYPE
	{	// struct for atomic operations on type _ITYPE
	__declspec(nothrow) _ITYPE operator=(_ITYPE) volatile;
	__declspec(nothrow) _ITYPE operator=(_ITYPE);

#if _HAS_CXX17
	static constexpr bool is_always_lock_free = true;
#endif /* _HAS_CXX17 */

	__declspec(nothrow) bool is_lock_free() const volatile;
	__declspec(nothrow) bool is_lock_free() const;
	__declspec(nothrow) void store(_ITYPE, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) void store(_ITYPE, memory_order = memory_order_seq_cst);
	__declspec(nothrow) _ITYPE load(memory_order = memory_order_seq_cst) const volatile;
	__declspec(nothrow) _ITYPE load(memory_order = memory_order_seq_cst) const;
#ifndef _ATOMIC_IS_ADDRESS_TYPE
	__declspec(nothrow) operator _ITYPE() const volatile;
	__declspec(nothrow) operator _ITYPE() const;
#endif /* _ATOMIC_IS_ADDRESS_TYPE */
	__declspec(nothrow) _ITYPE exchange(_ITYPE, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) _ITYPE exchange(_ITYPE, memory_order = memory_order_seq_cst);
	__declspec(nothrow) bool compare_exchange_weak(_ITYPE&, _ITYPE, memory_order, memory_order) volatile;
	__declspec(nothrow) bool compare_exchange_weak(_ITYPE&, _ITYPE, memory_order, memory_order);
	__declspec(nothrow) bool compare_exchange_strong(_ITYPE&, _ITYPE, memory_order, memory_order) volatile;
	__declspec(nothrow) bool compare_exchange_strong(_ITYPE&, _ITYPE, memory_order, memory_order);
	__declspec(nothrow) bool compare_exchange_weak(_ITYPE&, _ITYPE, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) bool compare_exchange_weak(_ITYPE&, _ITYPE, memory_order = memory_order_seq_cst);
	__declspec(nothrow) bool compare_exchange_strong(_ITYPE&, _ITYPE, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) bool compare_exchange_strong(_ITYPE&, _ITYPE, memory_order = memory_order_seq_cst);

 #ifdef _ATOMIC_HAS_ARITHMETIC_OPS
	__declspec(nothrow) _ITYPE operator++(int) volatile;
	__declspec(nothrow) _ITYPE operator++(int);
	__declspec(nothrow) _ITYPE operator--(int) volatile;
	__declspec(nothrow) _ITYPE operator--(int);
	__declspec(nothrow) _ITYPE operator++() volatile;
	__declspec(nothrow) _ITYPE operator++();
	__declspec(nothrow) _ITYPE operator--() volatile;
	__declspec(nothrow) _ITYPE operator--();
	__declspec(nothrow) _ITYPE operator+=(_ITYPE) volatile;
	__declspec(nothrow) _ITYPE operator+=(_ITYPE);
	__declspec(nothrow) _ITYPE operator-=(_ITYPE) volatile;
	__declspec(nothrow) _ITYPE operator-=(_ITYPE);
	__declspec(nothrow) _ITYPE operator&=(_ITYPE) volatile;
	__declspec(nothrow) _ITYPE operator&=(_ITYPE);
	__declspec(nothrow) _ITYPE operator|=(_ITYPE) volatile;
	__declspec(nothrow) _ITYPE operator|=(_ITYPE);
	__declspec(nothrow) _ITYPE operator^=(_ITYPE) volatile;
	__declspec(nothrow) _ITYPE operator^=(_ITYPE);

	__declspec(nothrow) _ITYPE fetch_add(_ITYPE, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) _ITYPE fetch_add(_ITYPE, memory_order = memory_order_seq_cst);
	__declspec(nothrow) _ITYPE fetch_sub(_ITYPE, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) _ITYPE fetch_sub(_ITYPE, memory_order = memory_order_seq_cst);
	__declspec(nothrow) _ITYPE fetch_and(_ITYPE, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) _ITYPE fetch_and(_ITYPE, memory_order = memory_order_seq_cst);
	__declspec(nothrow) _ITYPE fetch_or(_ITYPE, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) _ITYPE fetch_or(_ITYPE, memory_order = memory_order_seq_cst);
	__declspec(nothrow) _ITYPE fetch_xor(_ITYPE, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) _ITYPE fetch_xor(_ITYPE, memory_order = memory_order_seq_cst);
 #endif /* _ATOMIC_HAS_ARITHMETIC_OPS */

 #ifdef _ATOMIC_IS_ADDRESS_TYPE
	__declspec(nothrow) _ITYPE fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) _ITYPE fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);
	__declspec(nothrow) _ITYPE fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
	__declspec(nothrow) _ITYPE fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);
	__declspec(nothrow) _ITYPE operator+=(ptrdiff_t) volatile;
	__declspec(nothrow) _ITYPE operator+=(ptrdiff_t);
	__declspec(nothrow) _ITYPE operator-=(ptrdiff_t) volatile;
	__declspec(nothrow) _ITYPE operator-=(ptrdiff_t);
 #endif /* _ATOMIC_IS_ADDRESS_TYPE */


// x86's stack is 4-aligned, but atomic<int64_t> needs to be 8-aligned.
// Don't change this setting unless you know exactly what you're doing.

 #ifndef _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS
  #define _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS	1
 #endif /* _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS */

 #if _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS
	alignas(sizeof(_ATOMIC_UINT)) _ATOMIC_UINT _My_val;
 #else /* _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS */
	_ATOMIC_UINT _My_val;
 #endif /* _HAS_CORRECTLY_ALIGNED_ATOMIC_SPECIALIZATIONS */

	} _ATOMIC_ITYPE;

 #ifndef _ATOMIC_HAS_NO_SPECIALIZATION
		// TEMPLATE SPECIALIZATION atomic<_ITYPE>
template<>
	struct atomic<_ITYPE>
		: _ATOMIC_ITYPE
	{	/* template specialization that manages
			values of _ITYPE atomically */
	using value_type = _ITYPE;
	using difference_type = _ITYPE;

	atomic() _NOEXCEPT = default;

	__declspec(nothrow) constexpr atomic(_ITYPE _Val)
		: _ATOMIC_ITYPE{(_ATOMIC_UINT)_Val}
		{	// construct from _Val, initialization is not atomic
		}

	__declspec(nothrow) _ITYPE operator=(_ITYPE _Val) volatile
		{	// assign from _Val
		return (_ATOMIC_ITYPE::operator=(_Val));
		}

	__declspec(nothrow) _ITYPE operator=(_ITYPE _Val)
		{	// assign from _Val
		return (_ATOMIC_ITYPE::operator=(_Val));
		}

	atomic(const atomic&) = delete;
	atomic& operator=(const atomic&) = delete;
	atomic& operator=(const atomic&) volatile = delete;
	};
 #endif /* _ATOMIC_HAS_NO_SPECIALIZATION */

 #ifdef _ATOMIC_IS_ADDRESS_TYPE
		// STRUCT TEMPLATE PARTIAL SPECIALIZATION atomic<_Ty *>
template<class _Ty>
	struct atomic<_Ty *>
		: _Atomic_address
	{	// template that manages values of _Ty * atomically
	using value_type = _Ty *;
	using difference_type = ptrdiff_t;

	atomic(const atomic&) = delete;
	atomic& operator=(const atomic&) = delete;
	atomic& operator=(const atomic&) volatile = delete;

	atomic() _NOEXCEPT = default;

	__declspec(nothrow) constexpr atomic(_Ty *_Right)
		: _Atomic_address{(_ATOMIC_UINT)_Right}
		{	// construct from _Right, initialization is not atomic
		}

	__declspec(nothrow) _Ty *operator=(_Ty *_Right) volatile
		{	// assign from _Right
		return (reinterpret_cast<_Ty *>(
			_Atomic_address::operator=((void *)_Right)));
		}

	__declspec(nothrow) _Ty *operator=(_Ty *_Right)
		{	// assign from _Right
		return (reinterpret_cast<_Ty *>(
			_Atomic_address::operator=((void *)_Right)));
		}

	__declspec(nothrow) void store(_Ty *_Value, memory_order _Order = memory_order_seq_cst) volatile
		{	// store _Value into *this
		_Atomic_address::store((void *)_Value, _Order);
		}

	__declspec(nothrow) void store(_Ty *_Value, memory_order _Order = memory_order_seq_cst)
		{	// store _Value into *this
		_Atomic_address::store((void *)_Value, _Order);
		}

	__declspec(nothrow) _Ty *load(memory_order _Order = memory_order_seq_cst) const volatile
		{	// return value held in *this
		return (reinterpret_cast<_Ty *>(_Atomic_address::load(_Order)));
		}

	__declspec(nothrow) _Ty *load(memory_order _Order = memory_order_seq_cst) const
		{	// return value held in *this
		return (reinterpret_cast<_Ty *>(_Atomic_address::load(_Order)));
		}

	__declspec(nothrow) operator _Ty *() const volatile
		{	// return value held in *this
		return (load());
		}

	__declspec(nothrow) operator _Ty *() const
		{	// return value held in *this
		return (load());
		}

	__declspec(nothrow) _Ty *exchange(_Ty *_Value, memory_order _Order = memory_order_seq_cst) volatile
		{	// exchange value stored in *this with _Value
		return (reinterpret_cast<_Ty *>(_Atomic_address::exchange(
			(void *)_Value, _Order)));
		}

	__declspec(nothrow) _Ty *exchange(_Ty *_Value, memory_order _Order = memory_order_seq_cst)
		{	// exchange value stored in *this with _Value
		return (reinterpret_cast<_Ty *>(_Atomic_address::exchange(
			(void *)_Value, _Order)));
		}

	__declspec(nothrow) bool compare_exchange_weak(
		_Ty *& _Exp, _Ty *_Value,
		memory_order _Order1, memory_order _Order2) volatile
		{	// compare and exchange value stored in *this with *_Exp, _Value
		return (_Atomic_address::compare_exchange_weak(
			(void *&)_Exp, (void *)_Value, _Order1, _Order2));
		}

	__declspec(nothrow) bool compare_exchange_weak(
		_Ty *& _Exp, _Ty *_Value,
		memory_order _Order1, memory_order _Order2)
		{	// compare and exchange value stored in *this with *_Exp, _Value
		return (_Atomic_address::compare_exchange_weak(
			(void *&)_Exp, (void *)_Value, _Order1, _Order2));
		}

	__declspec(nothrow) bool compare_exchange_weak(
		_Ty *& _Exp, _Ty *_Value,
		memory_order _Order = memory_order_seq_cst) volatile
		{	// compare and exchange value stored in *this with *_Exp, _Value
		return (_Atomic_address::compare_exchange_weak(
			(void *&)_Exp, (void *)_Value, _Order));
		}

	__declspec(nothrow) bool compare_exchange_weak(
		_Ty *& _Exp, _Ty *_Value,
		memory_order _Order = memory_order_seq_cst)
		{	// compare and exchange value stored in *this with *_Exp, _Value
		return (_Atomic_address::compare_exchange_weak(
			(void *&)_Exp, (void *)_Value, _Order));
		}

	__declspec(nothrow) bool compare_exchange_strong(
		_Ty *& _Exp, _Ty *_Value,
		memory_order _Order1, memory_order _Order2) volatile
		{	// compare and exchange value stored in *this with *_Exp, _Value
		return (_Atomic_address::compare_exchange_strong(
			(void *&)_Exp, (void *)_Value, _Order1, _Order2));
		}

	__declspec(nothrow) bool compare_exchange_strong(
		_Ty *& _Exp, _Ty *_Value,
		memory_order _Order1, memory_order _Order2)
		{	// compare and exchange value stored in *this with *_Exp, _Value
		return (_Atomic_address::compare_exchange_strong(
			(void *&)_Exp, (void *)_Value, _Order1, _Order2));
		}

	__declspec(nothrow) bool compare_exchange_strong(
		_Ty *& _Exp, _Ty *_Value,
		memory_order _Order = memory_order_seq_cst) volatile
		{	// compare and exchange value stored in *this with *_Exp, _Value
		return (_Atomic_address::compare_exchange_strong(
			(void *&)_Exp, (void *)_Value, _Order));
		}

	__declspec(nothrow) bool compare_exchange_strong(
		_Ty *& _Exp, _Ty *_Value,
		memory_order _Order = memory_order_seq_cst)
		{	// compare and exchange value stored in *this with *_Exp, _Value
		return (_Atomic_address::compare_exchange_strong(
			(void *&)_Exp, (void *)_Value, _Order));
		}

	__declspec(nothrow) _Ty *fetch_add(ptrdiff_t _Value, memory_order _Order = memory_order_seq_cst) volatile
		{	// add _Value to value stored in *this
		return (reinterpret_cast<_Ty *>(
			_Atomic_address::fetch_add(_Value * sizeof (_Ty), _Order)));
		}

	__declspec(nothrow) _Ty *fetch_add(ptrdiff_t _Value, memory_order _Order = memory_order_seq_cst)
		{	// add _Value to value stored in *this
		return (reinterpret_cast<_Ty *>(
			_Atomic_address::fetch_add(_Value * sizeof (_Ty), _Order)));
		}

	__declspec(nothrow) _Ty *fetch_sub(ptrdiff_t _Value, memory_order _Order = memory_order_seq_cst) volatile
		{	// subtract _Value from value stored in *this
		return (reinterpret_cast<_Ty *>(
			_Atomic_address::fetch_sub(_Value * sizeof (_Ty), _Order)));
		}

	__declspec(nothrow) _Ty *fetch_sub(ptrdiff_t _Value, memory_order _Order = memory_order_seq_cst)
		{	// subtract _Value from value stored in *this
		return (reinterpret_cast<_Ty *>(
			_Atomic_address::fetch_sub(_Value * sizeof (_Ty), _Order)));
		}

	__declspec(nothrow) _Ty *operator++(int) volatile
		{	// increment stored pointer
		return (fetch_add(1));
		}

	__declspec(nothrow) _Ty *operator++(int)
		{	// increment stored pointer
		return (fetch_add(1));
		}

	__declspec(nothrow) _Ty *operator--(int) volatile
		{	// decrement stored pointer
		return (fetch_sub(1));
		}

	__declspec(nothrow) _Ty *operator--(int)
		{	// decrement stored pointer
		return (fetch_sub(1));
		}

	__declspec(nothrow) _Ty *operator+=(ptrdiff_t _Right) volatile
		{	// add _Right to value stored in *this
		return (fetch_add(_Right) + _Right);
		}

	__declspec(nothrow) _Ty *operator+=(ptrdiff_t _Right)
		{	// add _Right to value stored in *this
		return (fetch_add(_Right) + _Right);
		}

	__declspec(nothrow) _Ty *operator-=(ptrdiff_t _Right) volatile
		{	// subtract _Right from value stored in *this
		return (fetch_sub(_Right) - _Right);
		}

	__declspec(nothrow) _Ty *operator-=(ptrdiff_t _Right)
		{	// subtract _Right from value stored in *this
		return (fetch_sub(_Right) - _Right);
		}

	__declspec(nothrow) _Ty *operator++() volatile
		{	// increment stored pointer
		return (*this += 1);
		}

	__declspec(nothrow) _Ty *operator++()
		{	// increment stored pointer
		return (*this += 1);
		}

	__declspec(nothrow) _Ty *operator--() volatile
		{	// decrement stored pointer
		return (*this -= 1);
		}

	__declspec(nothrow) _Ty *operator--()
		{	// decrement stored pointer
		return (*this -= 1);
		}
	};
 #endif /* _ATOMIC_IS_ADDRESS_TYPE */

		// CORE NON-MEMBER FUNCTIONS
	// FUNCTION TEMPLATE atomic_is_lock_free
__declspec(nothrow) inline bool atomic_is_lock_free(const volatile _ATOMIC_ITYPE *)
	{	// return true if operations on _ATOMIC_ITYPE are lock-free
	return (true);
	}

__declspec(nothrow) inline bool atomic_is_lock_free(const _ATOMIC_ITYPE *)
	{	// return true if operations on _ATOMIC_ITYPE are lock-free
	return (true);
	}

 #ifndef _ATOMIC_HAS_NO_SPECIALIZATION
__declspec(nothrow) inline bool atomic_is_lock_free(const volatile atomic<_ITYPE> *)
	{	// return true if operations on _ATOMIC_ITYPE are lock-free
	return (true);
	}

__declspec(nothrow) inline bool atomic_is_lock_free(const atomic<_ITYPE> *)
	{	// return true if operations on _ATOMIC_ITYPE are lock-free
	return (true);
	}
 #endif /* _ATOMIC_HAS_NO_SPECIALIZATION */

	// FUNCTION TEMPLATE atomic_init
__declspec(nothrow) inline void atomic_init(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// non-atomically initialize *_Atom to _Value
	_Atom->_My_val = (_ATOMIC_UINT)_Value;

	}

__declspec(nothrow) inline void atomic_init(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// non-atomically initialize *_Atom to _Value
	_Atom->_My_val = (_ATOMIC_UINT)_Value;

	}

 #ifndef _ATOMIC_HAS_NO_SPECIALIZATION
__declspec(nothrow) inline void atomic_init(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{	// non-atomically initialize *_Atom to _Value
	_Atom->_My_val = (_ATOMIC_UINT)_Value;

	}

__declspec(nothrow) inline void atomic_init(atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{	// non-atomically initialize *_Atom to _Value
	_Atom->_My_val = (_ATOMIC_UINT)_Value;

	}
 #endif /* _ATOMIC_HAS_NO_SPECIALIZATION */

__declspec(nothrow) inline void atomic_store_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
	memory_order _Order)
	{	// store _Value into *_Atom
	_ATOMIC_STORE(_Atom, _Value, _Order);
	}

__declspec(nothrow) inline void atomic_store_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
	{	// store _Value into *_Atom
	_ATOMIC_STORE(_Atom, _Value, _Order);
	}

__declspec(nothrow) inline void atomic_store(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// store _Value into *_Atom
	atomic_store_explicit(_Atom, _Value, memory_order_seq_cst);
	}

__declspec(nothrow) inline void atomic_store(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// store _Value into *_Atom
	atomic_store_explicit(_Atom, _Value, memory_order_seq_cst);
	}

__declspec(nothrow) inline _ITYPE atomic_load_explicit(const volatile _ATOMIC_ITYPE *_Atom, memory_order _Order)
	{	// return value held in *_Atom
	return (_ATOMIC_LOAD(_Atom, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_load_explicit(const _ATOMIC_ITYPE *_Atom, memory_order _Order)
	{	// return value held in *_Atom
	return (_ATOMIC_LOAD(_Atom, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_load(const volatile _ATOMIC_ITYPE *_Atom)
	{	// return value stored in *_Atom
	return (atomic_load_explicit(_Atom, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_load(const _ATOMIC_ITYPE *_Atom)
	{	// return value stored in *_Atom
	return (atomic_load_explicit(_Atom, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_exchange_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
	memory_order _Order)
	{	// exchange value stored in *_Atom with _Value
	return (_ATOMIC_EXCHANGE(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_exchange_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
	{	// exchange value stored in *_Atom with _Value
	return (_ATOMIC_EXCHANGE(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_exchange(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// exchange value stored in *_Atom with _Value
	return (atomic_exchange_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_exchange(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// exchange value stored in *_Atom with _Value
	return (atomic_exchange_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline bool atomic_compare_exchange_weak_explicit(
	volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value,
	memory_order _Order1, memory_order _Order2)
	{	// compare and exchange value stored in *_Atom with *_Exp, _Value
	return (_ATOMIC_COMPARE_EXCHANGE_WEAK(_Atom, _Exp, _Value,
		_Order1, _Order2));
	}

__declspec(nothrow) inline bool atomic_compare_exchange_weak_explicit(
	_ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value,
	memory_order _Order1, memory_order _Order2)
	{	// compare and exchange value stored in *_Atom with *_Exp, _Value
	return (_ATOMIC_COMPARE_EXCHANGE_WEAK(_Atom, _Exp, _Value,
		_Order1, _Order2));
	}

__declspec(nothrow) inline bool atomic_compare_exchange_weak(
	volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value)
	{	// compare and exchange value stored in *_Atom with *_Exp, _Value
	return (atomic_compare_exchange_weak_explicit(
		_Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst));
	}

__declspec(nothrow) inline bool atomic_compare_exchange_weak(
	_ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value)
	{	// compare and exchange value stored in *_Atom with *_Exp, _Value
	return (atomic_compare_exchange_weak_explicit(
		_Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst));
	}

__declspec(nothrow) inline bool atomic_compare_exchange_strong_explicit(
	volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value,
	memory_order _Order1, memory_order _Order2)
	{	// compare and exchange value stored in *_Atom with *_Exp, _Value
	return (_ATOMIC_COMPARE_EXCHANGE_STRONG(_Atom, _Exp, _Value,
		_Order1, _Order2));
	}

__declspec(nothrow) inline bool atomic_compare_exchange_strong_explicit(
	_ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value,
	memory_order _Order1, memory_order _Order2)
	{	// compare and exchange value stored in *_Atom with *_Exp, _Value
	return (_ATOMIC_COMPARE_EXCHANGE_STRONG(_Atom, _Exp, _Value,
		_Order1, _Order2));
	}

__declspec(nothrow) inline bool atomic_compare_exchange_strong(
	volatile _ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value)
	{	// compare and exchange value stored in *_Atom with *_Exp, _Value
	return (atomic_compare_exchange_strong_explicit(
		_Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst));
	}

__declspec(nothrow) inline bool atomic_compare_exchange_strong(
	_ATOMIC_ITYPE *_Atom, _ITYPE *_Exp, _ITYPE _Value)
	{	// compare and exchange value stored in *_Atom with *_Exp, _Value
	return (atomic_compare_exchange_strong_explicit(
		_Atom, _Exp, _Value, memory_order_seq_cst, memory_order_seq_cst));
	}

		// CORE MEMBER FUNCTIONS
__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator=(_ITYPE _Value) volatile
	{	// assign _Value to *this
	atomic_store(this, _Value);
	return (_Value);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator=(_ITYPE _Value)
	{	// assign _Value to *this
	atomic_store(this, _Value);
	return (_Value);
	}

__declspec(nothrow) inline bool _ATOMIC_ITYPE::is_lock_free() const volatile
	{	// return true if operations on *this are lock-free
	return (atomic_is_lock_free(this));
	}

__declspec(nothrow) inline bool _ATOMIC_ITYPE::is_lock_free() const
	{	// return true if operations on *this are lock-free
	return (atomic_is_lock_free(this));
	}

__declspec(nothrow) inline void _ATOMIC_ITYPE::store(_ITYPE _Value, memory_order _Order) volatile
	{	// store _Value into *this
	atomic_store_explicit(this, _Value, _Order);
	}

__declspec(nothrow) inline void _ATOMIC_ITYPE::store(_ITYPE _Value, memory_order _Order)
	{	// store _Value into *this
	atomic_store_explicit(this, _Value, _Order);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::load(memory_order _Order) const volatile
	{	// return value held in *this
	return (atomic_load_explicit(this, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::load(memory_order _Order) const
	{	// return value held in *this
	return (atomic_load_explicit(this, _Order));
	}

#ifndef _ATOMIC_IS_ADDRESS_TYPE
__declspec(nothrow) inline _ATOMIC_ITYPE::operator _ITYPE() const volatile
	{	// return value held in *this
	return (atomic_load(this));
	}

__declspec(nothrow) inline _ATOMIC_ITYPE::operator _ITYPE() const
	{	// return value held in *this
	return (atomic_load(this));
	}
#endif // _ATOMIC_IS_ADDRESS_TYPE

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::exchange(_ITYPE _Value, memory_order _Order) volatile
	{	// exchange value stored in *this with _Value
	return (atomic_exchange_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::exchange(_ITYPE _Value, memory_order _Order)
	{	// exchange value stored in *this with _Value
	return (atomic_exchange_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_weak(
	_ITYPE& _Exp, _ITYPE _Value,
	memory_order _Order1, memory_order _Order2) volatile
	{	// compare and exchange value stored in *this with *_Exp, _Value
	return (atomic_compare_exchange_weak_explicit(
		this, &_Exp, _Value, _Order1, _Order2));
	}

__declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_weak(
	_ITYPE& _Exp, _ITYPE _Value,
	memory_order _Order1, memory_order _Order2)
	{	// compare and exchange value stored in *this with *_Exp, _Value
	return (atomic_compare_exchange_weak_explicit(
		this, &_Exp, _Value, _Order1, _Order2));
	}

__declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_weak(
	_ITYPE& _Exp, _ITYPE _Value,
	memory_order _Order) volatile
	{	// compare and exchange value stored in *this with *_Exp, _Value
	return (atomic_compare_exchange_weak_explicit(
		this, &_Exp, _Value, _Order, _Get_memory_order(_Order)));
	}

__declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_weak(
	_ITYPE& _Exp, _ITYPE _Value,
	memory_order _Order)
	{	// compare and exchange value stored in *this with *_Exp, _Value
	return (atomic_compare_exchange_weak_explicit(
		this, &_Exp, _Value, _Order, _Get_memory_order(_Order)));
	}

__declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_strong(
	_ITYPE& _Exp, _ITYPE _Value,
	memory_order _Order1, memory_order _Order2) volatile
	{	// compare and exchange value stored in *this with *_Exp, _Value
	return (atomic_compare_exchange_strong_explicit(
		this, &_Exp, _Value, _Order1, _Order2));
	}

__declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_strong(
	_ITYPE& _Exp, _ITYPE _Value,
	memory_order _Order1, memory_order _Order2)
	{	// compare and exchange value stored in *this with *_Exp, _Value
	return (atomic_compare_exchange_strong_explicit(
		this, &_Exp, _Value, _Order1, _Order2));
	}

__declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_strong(
	_ITYPE& _Exp, _ITYPE _Value,
	memory_order _Order) volatile
	{	// compare and exchange value stored in *this with *_Exp, _Value
	return (atomic_compare_exchange_strong_explicit(
		this, &_Exp, _Value, _Order, _Get_memory_order(_Order)));
	}

__declspec(nothrow) inline bool _ATOMIC_ITYPE::compare_exchange_strong(
	_ITYPE& _Exp, _ITYPE _Value,
	memory_order _Order)
	{	// compare and exchange value stored in *this with *_Exp, _Value
	return (atomic_compare_exchange_strong_explicit(
		this, &_Exp, _Value, _Order, _Get_memory_order(_Order)));
	}

		// SPECIALIZATIONS OF GENERAL OPERATIONS ON ATOMIC TYPES
 #ifndef _ATOMIC_HAS_NO_SPECIALIZATION
template<>
	__declspec(nothrow) inline bool atomic_is_lock_free(const volatile atomic<_ITYPE> *_Atom)
	{
	return (atomic_is_lock_free(
		static_cast<const volatile _ATOMIC_ITYPE *>(_Atom)));
	}

template<>
	__declspec(nothrow) inline bool atomic_is_lock_free(const atomic<_ITYPE> *_Atom)
	{
	return (atomic_is_lock_free(static_cast<const _ATOMIC_ITYPE *>(_Atom)));
	}

template<>
	__declspec(nothrow) inline void atomic_init(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	atomic_init(static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value);
	}

template<>
	__declspec(nothrow) inline void atomic_init(atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	atomic_init(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value);
	}

template<>
	__declspec(nothrow) inline void atomic_store(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	atomic_store(static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value);
	}

template<>
	__declspec(nothrow) inline void atomic_store(atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	atomic_store(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value);
	}

template<>
	__declspec(nothrow) inline void atomic_store_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	atomic_store_explicit(static_cast<volatile _ATOMIC_ITYPE *>(_Atom),
		_Value, _Order);
	}

template<>
	__declspec(nothrow) inline void atomic_store_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value, memory_order _Order)
	{
	atomic_store_explicit(static_cast<_ATOMIC_ITYPE *>(_Atom),
		_Value, _Order);
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_load(const volatile atomic<_ITYPE> *_Atom)
	{
	return (atomic_load(static_cast<const volatile _ATOMIC_ITYPE *>(_Atom)));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_load(const atomic<_ITYPE> *_Atom)
	{
	return (atomic_load(static_cast<const volatile _ATOMIC_ITYPE *>(_Atom)));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_load_explicit(const volatile atomic<_ITYPE> *_Atom, memory_order _Order)
	{
	return (atomic_load_explicit(
		static_cast<const volatile _ATOMIC_ITYPE *>(_Atom), _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_load_explicit(const atomic<_ITYPE> *_Atom, memory_order _Order)
	{
	return (atomic_load_explicit(
		static_cast<const _ATOMIC_ITYPE *>(_Atom), _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_exchange(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_exchange(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_exchange(atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_exchange(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_exchange_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_exchange_explicit(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_exchange_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_exchange_explicit(static_cast<_ATOMIC_ITYPE *>(_Atom),
		_Value, _Order));
	}

template<>
	__declspec(nothrow) inline bool atomic_compare_exchange_weak(
		volatile atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value)
	{
	return (atomic_compare_exchange_weak(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp, _Value));
	}

template<>
	__declspec(nothrow) inline bool atomic_compare_exchange_weak(
		atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value)
	{
	return (atomic_compare_exchange_weak(
		static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value));
	}

template<>
	__declspec(nothrow) inline bool atomic_compare_exchange_weak_explicit(
		volatile atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value,
		memory_order _Order1, memory_order _Order2)
	{
	return (atomic_compare_exchange_weak_explicit(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp,
			_Value, _Order1, _Order2));
	}

template<>
	__declspec(nothrow) inline bool atomic_compare_exchange_weak_explicit(
		atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value,
		memory_order _Order1, memory_order _Order2)
	{
	return (atomic_compare_exchange_weak_explicit(
		static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value, _Order1, _Order2));
	}

template<>
	__declspec(nothrow) inline bool atomic_compare_exchange_strong(
		volatile atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value)
	{
	return (atomic_compare_exchange_strong(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp, _Value));
	}

template<>
	__declspec(nothrow) inline bool atomic_compare_exchange_strong(
		atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value)
	{
	return (atomic_compare_exchange_strong(
		static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value));
	}

template<>
	__declspec(nothrow) inline bool atomic_compare_exchange_strong_explicit(
		volatile atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value,
		memory_order _Order1, memory_order _Order2)
	{
	return (atomic_compare_exchange_strong_explicit(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Exp,
			_Value, _Order1, _Order2));
	}

template<>
	__declspec(nothrow) inline bool atomic_compare_exchange_strong_explicit(
		atomic<_ITYPE> *_Atom, _ITYPE *_Exp, _ITYPE _Value,
		memory_order _Order1, memory_order _Order2)
	{
	return (atomic_compare_exchange_strong_explicit(
		static_cast<_ATOMIC_ITYPE *>(_Atom), _Exp, _Value, _Order1, _Order2));
	}
 #endif /* _ATOMIC_HAS_NO_SPECIALIZATION */

 #ifdef _ATOMIC_HAS_ARITHMETIC_OPS
		// ARITHMETIC NON-MEMBER FUNCTIONS
__declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(
	volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
	{	// add _Value to value stored in *_Atom
	return (_ATOMIC_FETCH_ADD(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(
	_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
	{	// add _Value to value stored in *_Atom
	return (_ATOMIC_FETCH_ADD(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_add(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// add _Value to value stored in *_Atom
	return (atomic_fetch_add_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_add(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// add _Value to value stored in *_Atom
	return (atomic_fetch_add_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
	memory_order _Order)
	{	// subtract _Value from value stored in *_Atom
	return (_ATOMIC_FETCH_SUB(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
	{	// subtract _Value from value stored in *_Atom
	return (_ATOMIC_FETCH_SUB(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_sub(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// subtract _Value from value stored in *_Atom
	return (atomic_fetch_sub_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_sub(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// subtract _Value from value stored in *_Atom
	return (atomic_fetch_sub_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_and_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
	memory_order _Order)
	{	// and _Value with value stored in *_Atom
	return (_ATOMIC_FETCH_AND(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_and_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
	{	// and _Value with value stored in *_Atom
	return (_ATOMIC_FETCH_AND(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_and(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// and _Value with value stored in *_Atom
	return (atomic_fetch_and_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_and(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// and _Value with value stored in *_Atom
	return (atomic_fetch_and_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_or_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
	memory_order _Order)
	{	// or _Value with value stored in *_Atom
	return (_ATOMIC_FETCH_OR(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_or_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
	{	// or _Value with value stored in *_Atom
	return (_ATOMIC_FETCH_OR(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_or(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// or _Value with value stored in *_Atom
	return (atomic_fetch_or_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_or(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// or _Value with value stored in *_Atom
	return (atomic_fetch_or_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_xor_explicit(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value,
	memory_order _Order)
	{	// xor _Value with value stored in *_Atom
	return (_ATOMIC_FETCH_XOR(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_xor_explicit(_ATOMIC_ITYPE *_Atom, _ITYPE _Value, memory_order _Order)
	{	// xor _Value with value stored in *_Atom
	return (_ATOMIC_FETCH_XOR(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_xor(volatile _ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// xor _Value with value stored in *_Atom
	return (atomic_fetch_xor_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_xor(_ATOMIC_ITYPE *_Atom, _ITYPE _Value)
	{	// xor _Value with value stored in *_Atom
	return (atomic_fetch_xor_explicit(_Atom, _Value, memory_order_seq_cst));
	}

		// ARITHMETIC MEMBER FUNCTIONS
__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator++(int) volatile
	{	// increment value stored in *this
	return (atomic_fetch_add(this, 1));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator++(int)
	{	// increment value stored in *this
	return (atomic_fetch_add(this, 1));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator--(int) volatile
	{	// decrement value stored in *this
	return (atomic_fetch_sub(this, 1));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator--(int)
	{	// decrement value stored in *this
	return (atomic_fetch_sub(this, 1));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator++() volatile
	{	// increment value stored in *this
	return (atomic_fetch_add(this, 1) + 1);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator++()
	{	// increment value stored in *this
	return (atomic_fetch_add(this, 1) + 1);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator--() volatile
	{	// decrement value stored in *this
	return (atomic_fetch_sub(this, 1) - 1);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator--()
	{	// decrement value stored in *this
	return (atomic_fetch_sub(this, 1) - 1);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator+=(_ITYPE _Right) volatile
	{	// add _Right to value stored in *this
	return (atomic_fetch_add(this, _Right) + _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator+=(_ITYPE _Right)
	{	// add _Right to value stored in *this
	return (atomic_fetch_add(this, _Right) + _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator-=(_ITYPE _Right) volatile
	{	// subtract _Right from value stored in *this
	return (atomic_fetch_sub(this, _Right) - _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator-=(_ITYPE _Right)
	{	// subtract _Right from value stored in *this
	return (atomic_fetch_sub(this, _Right) - _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator&=(_ITYPE _Right) volatile
	{	// and _Right with value stored in *this
	return (atomic_fetch_and(this, _Right) & _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator&=(_ITYPE _Right)
	{	// and _Right with value stored in *this
	return (atomic_fetch_and(this, _Right) & _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator|=(_ITYPE _Right) volatile
	{	// or _Right with value stored in *this
	return (atomic_fetch_or(this, _Right) | _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator|=(_ITYPE _Right)
	{	// or _Right with value stored in *this
	return (atomic_fetch_or(this, _Right) | _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator^=(_ITYPE _Right) volatile
	{	// xor _Right with value stored in *this
	return (atomic_fetch_xor(this, _Right) ^ _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator^=(_ITYPE _Right)
	{	// xor _Right with value stored in *this
	return (atomic_fetch_xor(this, _Right) ^ _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_add(_ITYPE _Value, memory_order _Order) volatile
	{	// add _Value to value stored in *this
	return (atomic_fetch_add_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_add(_ITYPE _Value, memory_order _Order)
	{	// add _Value to value stored in *this
	return (atomic_fetch_add_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_sub(_ITYPE _Value, memory_order _Order) volatile
	{	// subtract _Value from value stored in *this
	return (atomic_fetch_sub_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_sub(_ITYPE _Value, memory_order _Order)
	{	// subtract _Value from value stored in *this
	return (atomic_fetch_sub_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_and(_ITYPE _Value, memory_order _Order) volatile
	{	// and _Value with value stored in *this
	return (atomic_fetch_and_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_and(_ITYPE _Value, memory_order _Order)
	{	// and _Value with value stored in *this
	return (atomic_fetch_and_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_or(_ITYPE _Value, memory_order _Order) volatile
	{	// or _Value with value stored in *this
	return (atomic_fetch_or_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_or(_ITYPE _Value, memory_order _Order)
	{	// or _Value with value stored in *this
	return (atomic_fetch_or_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_xor(_ITYPE _Value, memory_order _Order) volatile
	{	// xor _Value with value stored in *this
	return (atomic_fetch_xor_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_xor(_ITYPE _Value, memory_order _Order)
	{	// xor _Value with value stored in *this
	return (atomic_fetch_xor_explicit(this, _Value, _Order));
	}

	// SPECIALIZATIONS OF ARITHMETIC OPERATIONS ON ATOMIC TYPES
 #ifndef _ATOMIC_HAS_NO_SPECIALIZATION
template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_add(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_fetch_add(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_add(atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_fetch_add(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_fetch_add_explicit(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_fetch_add_explicit(
		static_cast<_ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_sub(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_fetch_sub(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_sub(atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_fetch_sub(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_fetch_sub_explicit(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_fetch_sub_explicit(
		static_cast<_ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_and(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_fetch_and(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_and(atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_fetch_and(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_and_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_fetch_and_explicit(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_and_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_fetch_and_explicit(
		static_cast<_ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_or(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_fetch_or(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_or(atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_fetch_or(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_or_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_fetch_or_explicit(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_or_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_fetch_or_explicit(
		static_cast<_ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_xor(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_fetch_xor(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_xor(atomic<_ITYPE> *_Atom, _ITYPE _Value)
	{
	return (atomic_fetch_xor(static_cast<_ATOMIC_ITYPE *>(_Atom), _Value));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_xor_explicit(volatile atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_fetch_xor_explicit(
		static_cast<volatile _ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}

template<>
	__declspec(nothrow) inline _ITYPE atomic_fetch_xor_explicit(atomic<_ITYPE> *_Atom, _ITYPE _Value,
		memory_order _Order)
	{
	return (atomic_fetch_xor_explicit(
		static_cast<_ATOMIC_ITYPE *>(_Atom), _Value, _Order));
	}
 #endif /* _ATOMIC_HAS_NO_SPECIALIZATION */
 #endif /* _ATOMIC_HAS_ARITHMETIC_OPS */

 #ifdef _ATOMIC_IS_ADDRESS_TYPE
		// ADDRESS NON-MEMBER FUNCTIONS
__declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(volatile _ATOMIC_ITYPE *_Atom, ptrdiff_t _Value,
	memory_order _Order)
	{	// add _Value to value stored in *_Atom
	return ((_ITYPE)_ATOMIC_FETCH_ADD(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_add_explicit(_ATOMIC_ITYPE *_Atom, ptrdiff_t _Value,
	memory_order _Order)
	{	// add _Value to value stored in *_Atom
	return ((_ITYPE)_ATOMIC_FETCH_ADD(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_add(volatile _ATOMIC_ITYPE *_Atom, ptrdiff_t _Value)
	{	// add _Value to value stored in *_Atom
	return (atomic_fetch_add_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_add(_ATOMIC_ITYPE *_Atom, ptrdiff_t _Value)
	{	// add _Value to value stored in *_Atom
	return (atomic_fetch_add_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(volatile _ATOMIC_ITYPE *_Atom, ptrdiff_t _Value,
	memory_order _Order)
	{	// subtract _Value from value stored in *_Atom
	return ((_ITYPE)_ATOMIC_FETCH_SUB(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_sub_explicit(_ATOMIC_ITYPE *_Atom, ptrdiff_t _Value,
	memory_order _Order)
	{	// subtract _Value from value stored in *_Atom
	return ((_ITYPE)_ATOMIC_FETCH_SUB(_Atom, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_sub(volatile _ATOMIC_ITYPE *_Atom, ptrdiff_t _Value)
	{	// subtract _Value from value stored in *_Atom
	return (atomic_fetch_sub_explicit(_Atom, _Value, memory_order_seq_cst));
	}

__declspec(nothrow) inline _ITYPE atomic_fetch_sub(_ATOMIC_ITYPE *_Atom, ptrdiff_t _Value)
	{	// subtract _Value from value stored in *_Atom
	return (atomic_fetch_sub_explicit(_Atom, _Value, memory_order_seq_cst));
	}

		// ADDRESS MEMBER FUNCTIONS
__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_add(ptrdiff_t _Value, memory_order _Order) volatile
	{	// add _Value to value stored in *this
	return (atomic_fetch_add_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_add(ptrdiff_t _Value, memory_order _Order)
	{	// add _Value to value stored in *this
	return (atomic_fetch_add_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_sub(ptrdiff_t _Value, memory_order _Order) volatile
	{	// subtract _Value from value stored in *this
	return (atomic_fetch_sub_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::fetch_sub(ptrdiff_t _Value, memory_order _Order)
	{	// subtract _Value from value stored in *this
	return (atomic_fetch_sub_explicit(this, _Value, _Order));
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator+=(ptrdiff_t _Right) volatile
	{	// add _Right to value stored in *this
	return ((char*)fetch_add(_Right) + _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator+=(ptrdiff_t _Right)
	{	// add _Right to value stored in *this
	return ((char*)fetch_add(_Right) + _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator-=(ptrdiff_t _Right) volatile
	{	// subtract _Right from value stored in *this
	return ((char*)fetch_sub(_Right) - _Right);
	}

__declspec(nothrow) inline _ITYPE _ATOMIC_ITYPE::operator-=(ptrdiff_t _Right)
	{	// subtract _Right from value stored in *this
	return ((char*)fetch_sub(_Right) - _Right);
	}
 #endif /* _ATOMIC_IS_ADDRESS_TYPE */

#undef _ATOMIC_FETCH_XOR
#undef _ATOMIC_FETCH_OR
#undef _ATOMIC_FETCH_AND
#undef _ATOMIC_FETCH_SUB
#undef _ATOMIC_FETCH_ADD
#undef _ATOMIC_COMPARE_EXCHANGE_STRONG
#undef _ATOMIC_COMPARE_EXCHANGE_WEAK
#undef _ATOMIC_EXCHANGE
#undef _ATOMIC_LOAD
#undef _ATOMIC_STORE
#undef _ATOMIC_LOCKING_PRIMITIVE_NAME
#undef _ATOMIC_LOCK_FREE_PRIMITIVE_NAME
#undef _ATOMIC_UINT

#undef _ATOMIC_IS_ADDRESS_TYPE
#undef _ATOMIC_HAS_NO_SPECIALIZATION
#undef _ATOMIC_HAS_ARITHMETIC_OPS
#undef _ISIZE
#undef _ITYPE
#undef _ATOMIC_ITYPE

/*
 * Copyright (c) by P.J. Plauger. All rights reserved.
 * Consult your license regarding permissions and restrictions.
V6.50:0009 */
