// xmemory0 internal header
#pragma once
#ifndef _XMEMORY0_
#define _XMEMORY0_
#ifndef RC_INVOKED
#include <cstdint>	/* for uintptr_t */
#include <cstdlib>
#include <limits>
#include <new>
#include <xutility>

 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,_STL_WARNING_LEVEL)
 #pragma warning(disable: _STL_DISABLED_WARNINGS)
 #pragma push_macro("new")
 #undef new

_STD_BEGIN
 #if defined(_M_IX86) || defined(_M_X64)
constexpr size_t _Big_allocation_threshold = 4096;
constexpr size_t _Big_allocation_alignment = 32;

static_assert(2 * sizeof(void *) <= _Big_allocation_alignment,
	"Big allocation alignment should at least match vector register alignment");
static_assert((_Big_allocation_alignment & (_Big_allocation_alignment - 1)) == 0,
	"Big allocation alignment must be a power of two");

  #ifdef _DEBUG
constexpr size_t _Non_user_size = 2 * sizeof(void *) + _Big_allocation_alignment - 1;
  #else /* _DEBUG */
constexpr size_t _Non_user_size = sizeof(void *) + _Big_allocation_alignment - 1;
  #endif /* _DEBUG */

  #ifdef _DEBUG
   #ifdef _WIN64
constexpr size_t _Big_allocation_sentinel = 0xFAFAFAFAFAFAFAFAULL;
   #else /* ^^^ _WIN64 ^^^ // vvv !_WIN64 vvv */
constexpr size_t _Big_allocation_sentinel = 0xFAFAFAFAUL;
   #endif /* _WIN64 */
  #endif /* _DEBUG */
 #endif /* defined(_M_IX86) || defined(_M_X64) */

		// FUNCTION TEMPLATE _Allocate
template<bool _Try_aligned = true>
	struct _Default_allocate_traits
	{
	static constexpr bool _Try_aligned_allocation = _Try_aligned;

	[[noreturn]] static void _Fail()
		{
		_Xbad_alloc();
		}

	_DECLSPEC_ALLOCATOR static void * _Get_bytes(const size_t _Bytes, const size_t _Align)
		{
		(void)_Align;

		void * _Ptr = nullptr;
 #if _HAS_ALIGNED_NEW // TRANSITION, if constexpr
		if (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
			{
			_Ptr = ::operator new(_Bytes, align_val_t{_Align});
			}
		else
 #endif /* _HAS_ALIGNED_NEW */
			{
			_Ptr = ::operator new(_Bytes);
			}

		_SCL_SECURE_ALWAYS_VALIDATE(_Ptr != nullptr);
		return (_Ptr);
		}
	};

template<class _Traits = _Default_allocate_traits<>> inline
	_DECLSPEC_ALLOCATOR void *_Allocate(const size_t _Count, const size_t _Sz, size_t _Align)
	{	// allocate storage for _Count elements of size _Sz with alignment _Align
	if (_Count == 0)
		{
		return (nullptr);
		}

	// check overflow of multiply
	if (static_cast<size_t>(-1) / _Sz < _Count)
		{
		_Traits::_Fail();	// report no memory
		}

	const size_t _User_size = _Count * _Sz;

#if defined(_M_IX86) || defined(_M_X64)
	// Boost the alignment of big allocations to help autovectorization.
 #pragma warning(push)
 #pragma warning(disable: 4127) // conditional expression is constant
 #pragma warning(disable: 6326) // Potential comparison of a constant with another constant
	if (_Traits::_Try_aligned_allocation && _User_size >= _Big_allocation_threshold)
		{
 #if _HAS_ALIGNED_NEW // TRANSITION, if constexpr
		if (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
			{	// allocation will use aligned new
			if /* constexpr */ (__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2 >= _Big_allocation_alignment)
				{	// There are no valid alignments between __STDCPP_DEFAULT_NEW_ALIGNMENT__
					// and _Big_allocation_alignment; the below conditional is dead.
				}
			else
				{
				if (_Align < _Big_allocation_alignment)
					{	// boost alignment
					_Align = _Big_allocation_alignment;
					}
				}
			}
		else
 #endif /* _HAS_ALIGNED_NEW */
			{	// allocation will use unaligned new; boost alignment manually
			const size_t _Block_size = _Non_user_size + _User_size;
			if (_Block_size <= _User_size)
				{
				_Traits::_Fail();	// report no memory
				}

			const uintptr_t _Ptr_container =
				reinterpret_cast<uintptr_t>(::operator new(_Block_size));
			_SCL_SECURE_ALWAYS_VALIDATE(_Ptr_container != 0);
			void * const _Ptr = reinterpret_cast<void *>((_Ptr_container + _Non_user_size)
				& ~(_Big_allocation_alignment - 1));
			static_cast<uintptr_t *>(_Ptr)[-1] = _Ptr_container;

 #ifdef _DEBUG
			static_cast<uintptr_t *>(_Ptr)[-2] = _Big_allocation_sentinel;
 #endif /* _DEBUG */
			return (_Ptr);
			}
		}
 #pragma warning(pop)
#endif /* defined(_M_IX86) || defined(_M_X64) */

	return (_Traits::_Get_bytes(_User_size, _Align));
	}

		// FUNCTION _Deallocate
inline void _Deallocate(void * _Ptr, const size_t _Count, const size_t _Sz, size_t _Align)
	{	// deallocate storage for _Count elements of size _Sz with alignment _Align
	(void)_Align;

	if (_Count > static_cast<size_t>(-1) / _Sz)
		{
		goto _Invalid_parameter; // TRANSITION, VSO#359498
		}

		{
		size_t _Allocated_size = _Count * _Sz;

#if defined(_M_IX86) || defined(_M_X64)
		// Boost the alignment of big allocations to help autovectorization.
 #pragma warning(push)
 #pragma warning(disable: 4127) // conditional expression is constant
 #pragma warning(disable: 6326) // Potential comparison of a constant with another constant
		if (_Allocated_size >= _Big_allocation_threshold)
			{
 #if _HAS_ALIGNED_NEW // TRANSITION, if constexpr
			if (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
				{	// allocation will use aligned new
				if /* constexpr */ (__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2 >= _Big_allocation_alignment)
					{	// There are no valid alignments between __STDCPP_DEFAULT_NEW_ALIGNMENT__
						// and _Big_allocation_alignment; the below conditional is dead.
					}
				else
					{
					if (_Align < _Big_allocation_alignment)
						{	// boost alignment
						_Align = _Big_allocation_alignment;
						}
					}
				}
			else
 #endif /* _HAS_ALIGNED_NEW */
				{	// allocation will use unaligned new; boost alignment manually
				if (_Allocated_size + _Non_user_size <= _Allocated_size)
					{
					goto _Invalid_parameter;
					}
				_Allocated_size += _Non_user_size;

				const uintptr_t _Ptr_user = reinterpret_cast<uintptr_t>(_Ptr);
				if ((_Ptr_user & (_Big_allocation_alignment - 1)) != 0)
					{
					goto _Invalid_parameter;
					}

				const uintptr_t _Ptr_ptr = _Ptr_user - sizeof(void *);
				const uintptr_t _Ptr_container =
					*reinterpret_cast<uintptr_t *>(_Ptr_ptr);

  #ifdef _DEBUG
				// If the following asserts, it likely means that we are performing
				// an aligned delete on memory coming from an unaligned allocation.
				if (reinterpret_cast<uintptr_t *>(_Ptr_ptr)[-1] != _Big_allocation_sentinel)
					{
					goto _Invalid_parameter;
					}
  #endif /* _DEBUG */

				// Extra paranoia on aligned allocation/deallocation
				if (_Ptr_container >= _Ptr_user)
					{
					goto _Invalid_parameter;
					}

  #ifdef _DEBUG
				if (2 * sizeof(void *) > _Ptr_user - _Ptr_container)
  #else /* _DEBUG */
				if (sizeof(void *) > _Ptr_user - _Ptr_container)
  #endif /* _DEBUG */
					{
					goto _Invalid_parameter;
					}

				if (_Ptr_user - _Ptr_container > _Non_user_size)
					{
					goto _Invalid_parameter;
					}

				_Ptr = reinterpret_cast<void *>(_Ptr_container);
				}
			}
 #pragma warning(pop)
#endif /* defined(_M_IX86) || defined(_M_X64) */

 #if _HAS_ALIGNED_NEW // TRANSITION, if constexpr
		if (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
			{
			::operator delete(_Ptr, _Allocated_size, align_val_t{_Align});
			}
		else
 #endif /* _HAS_ALIGNED_NEW */
			{
			::operator delete(_Ptr, _Allocated_size);
			}
		return;
		}

_Invalid_parameter:
	_SCL_SECURE_INVALID_ARGUMENT_NO_ASSERT;
	}

		// FUNCTION TEMPLATE _Construct_in_place
template<class _Ty,
	class... _Types> inline
	void _Construct_in_place(_Ty& _Obj, _Types&&... _Args)
		_NOEXCEPT_COND(is_nothrow_constructible_v<_Ty, _Types...>)
	{	// invoke True Placement New to initialize the referenced object with _Args...
	::new (const_cast<void *>(static_cast<const volatile void *>(_STD addressof(_Obj))))
		_Ty(_STD forward<_Types>(_Args)...);
	}

		// FUNCTION TEMPLATE _Global_new
template<class _Ty,
	class... _Types> inline
	_Ty * _Global_new(_Types&&... _Args)
	{	// acts as "new" while disallowing user overload selection
	void * const _Result = _Allocate(1, sizeof(_Ty), alignof(_Ty));
	_TRY_BEGIN
	::new (_Result) _Ty(_STD forward<_Types>(_Args)...);
	_CATCH_ALL
	_Deallocate(_Result, 1, sizeof(_Ty), alignof(_Ty));
	_RERAISE;
	_CATCH_END
	return (static_cast<_Ty *>(_Result));
	}

		// STRUCT TEMPLATE _Get_first_parameter
template<class _Ty>
	struct _Get_first_parameter;

template<template<class, class...> class _Ty,
	class _First,
	class... _Rest>
	struct _Get_first_parameter<_Ty<_First, _Rest...>>
	{	// given _Ty<_First, _Rest...>, extract _First
	using type = _First;
	};

		// STRUCT TEMPLATE _Replace_first_parameter
template<class _Newfirst,
	class _Ty>
	struct _Replace_first_parameter;

template<class _Newfirst,
	template<class, class...> class _Ty,
	class _First,
	class... _Rest>
	struct _Replace_first_parameter<_Newfirst, _Ty<_First, _Rest...>>
	{	// given _Ty<_First, _Rest...>, replace _First
	using type = _Ty<_Newfirst, _Rest...>;
	};

		// STRUCT TEMPLATE _Get_element_type
template<class _Ty,
	class = void>
	struct _Get_element_type
	{	// provide fallback
	using type = typename _Get_first_parameter<_Ty>::type;
	};

template<class _Ty>
	struct _Get_element_type<_Ty, void_t<typename _Ty::element_type>>
	{	// get _Ty::element_type
	using type = typename _Ty::element_type;
	};

		// STRUCT TEMPLATE _Get_ptr_difference_type
template<class _Ty,
	class = void>
	struct _Get_ptr_difference_type
	{	// provide fallback
	using type = ptrdiff_t;
	};

template<class _Ty>
	struct _Get_ptr_difference_type<_Ty, void_t<typename _Ty::difference_type>>
	{	// get _Ty::difference_type
	using type = typename _Ty::difference_type;
	};

		// STRUCT TEMPLATE _Get_rebind_alias
template<class _Ty,
	class _Other,
	class = void>
	struct _Get_rebind_alias
	{	// provide fallback
	using type = typename _Replace_first_parameter<_Other, _Ty>::type;
	};

template<class _Ty,
	class _Other>
	struct _Get_rebind_alias<_Ty, _Other, void_t<typename _Ty::template rebind<_Other>>>
	{	// get _Ty::rebind<_Other>
	using type = typename _Ty::template rebind<_Other>;
	};

		// STRUCT TEMPLATE pointer_traits
template<class _Ty>
	struct pointer_traits
	{	// defines traits for arbitrary pointers
	using element_type = typename _Get_element_type<_Ty>::type;
	using pointer = _Ty;
	using difference_type = typename _Get_ptr_difference_type<_Ty>::type;

	template<class _Other>
		using rebind = typename _Get_rebind_alias<_Ty, _Other>::type;

	using _Reftype = conditional_t<is_void_v<element_type>,
		char&,
		add_lvalue_reference_t<element_type>>;

	static pointer pointer_to(_Reftype _Val)
		{	// convert raw reference to pointer
		return (_Ty::pointer_to(_Val));
		}
	};

template<class _Ty>
	struct pointer_traits<_Ty *>
	{	// defines traits for raw pointers
	using element_type = _Ty;
	using pointer = _Ty *;
	using difference_type = ptrdiff_t;

	template<class _Other>
		using rebind = _Other *;

	using _Reftype = conditional_t<is_void_v<_Ty>,
		char&,
		add_lvalue_reference_t<_Ty>>;

	static pointer pointer_to(_Reftype _Val)
		{	// convert raw reference to pointer
		return (_STD addressof(_Val));
		}
	};

		// ALIAS TEMPLATE _Rebind_pointer_t
template<class _Ptr,
	class _Ty>
	using _Rebind_pointer_t = typename pointer_traits<_Ptr>::template rebind<_Ty>;

		// FUNCTION TEMPLATE _Refancy
template<class _Pointer,
	enable_if_t<!is_pointer_v<_Pointer>, int> = 0> inline
	_Pointer _Refancy(typename pointer_traits<_Pointer>::element_type * _Ptr)
	{	// transform a plain pointer into a fancy pointer
	return (pointer_traits<_Pointer>::pointer_to(*_Ptr));
	}

template<class _Pointer,
	enable_if_t<is_pointer_v<_Pointer>, int> = 0> inline
	_Pointer _Refancy(_Pointer _Ptr)
	{	// do nothing for plain pointers
	return (_Ptr);
	}

		// FUNCTION TEMPLATE _Destroy_in_place
template<class _Ty> inline
	void _Destroy_in_place(_Ty& _Obj) _NOEXCEPT
	{	// destroy the referenced object
	_Obj.~_Ty();
	}

		// FUNCTION TEMPLATE _Const_cast
template<class _Ptrty> inline
	auto _Const_cast(_Ptrty _Ptr)
	{	// remove constness from a fancy pointer
	using _Elem = typename pointer_traits<_Ptrty>::element_type;
	using _Modifiable = remove_const_t<_Elem>;
	using _Dest = typename pointer_traits<_Ptrty>::template rebind<_Modifiable>;

	return (pointer_traits<_Dest>::pointer_to(const_cast<_Modifiable&>(*_Ptr)));
	}

template<class _Ty> inline
	auto _Const_cast(_Ty * _Ptr)
	{	// remove constness from a plain pointer
	return (const_cast<remove_const_t<_Ty> *>(_Ptr));
	}

		// STRUCT TEMPLATE _Get_pointer_type
template<class _Ty,
	class = void>
	struct _Get_pointer_type
	{	// provide fallback
	using type = typename _Ty::value_type *;
	};

#pragma warning(push)
#pragma warning(disable: 4996)	// was declared deprecated
template<class _Ty>
	struct _Get_pointer_type<_Ty, void_t<typename _Ty::pointer>>
	{	// get _Ty::pointer
	using type = typename _Ty::pointer;
	};
#pragma warning(pop)

		// STRUCT TEMPLATE _Get_const_pointer_type
template<class _Ty,
	class = void>
	struct _Get_const_pointer_type
	{	// provide fallback
	using _Ptrty = typename _Get_pointer_type<_Ty>::type;
	using _Valty = typename _Ty::value_type;
	using type = typename pointer_traits<_Ptrty>::template rebind<const _Valty>;
	};

#pragma warning(push)
#pragma warning(disable: 4996)	// was declared deprecated
template<class _Ty>
	struct _Get_const_pointer_type<_Ty, void_t<typename _Ty::const_pointer>>
	{	// get _Ty::const_pointer
	using type = typename _Ty::const_pointer;
	};
#pragma warning(pop)

		// STRUCT TEMPLATE _Get_void_pointer_type
template<class _Ty,
	class = void>
	struct _Get_void_pointer_type
	{	// provide fallback
	using _Ptrty = typename _Get_pointer_type<_Ty>::type;
	using type = typename pointer_traits<_Ptrty>::template rebind<void>;
	};

template<class _Ty>
	struct _Get_void_pointer_type<_Ty, void_t<typename _Ty::void_pointer>>
	{	// get _Ty::void_pointer
	using type = typename _Ty::void_pointer;
	};

		// STRUCT TEMPLATE _Get_const_void_pointer_type
template<class _Ty,
	class = void>
	struct _Get_const_void_pointer_type
	{	// provide fallback
	using _Ptrty = typename _Get_pointer_type<_Ty>::type;
	using type = typename pointer_traits<_Ptrty>::template rebind<const void>;
	};

template<class _Ty>
	struct _Get_const_void_pointer_type<_Ty, void_t<typename _Ty::const_void_pointer>>
	{	// get _Ty::const_void_pointer
	using type = typename _Ty::const_void_pointer;
	};

		// STRUCT TEMPLATE _Get_difference_type
template<class _Ty,
	class = void>
	struct _Get_difference_type
	{	// provide fallback
	using _Ptrty = typename _Get_pointer_type<_Ty>::type;
	using type = typename pointer_traits<_Ptrty>::difference_type;
	};

#pragma warning(push)
#pragma warning(disable: 4996)	// was declared deprecated
template<class _Ty>
	struct _Get_difference_type<_Ty, void_t<typename _Ty::difference_type>>
	{	// get _Ty::difference_type
	using type = typename _Ty::difference_type;
	};
#pragma warning(pop)

		// STRUCT TEMPLATE _Get_size_type
template<class _Ty,
	class = void>
	struct _Get_size_type
	{	// provide fallback
	using type = make_unsigned_t<typename _Get_difference_type<_Ty>::type>;
	};

#pragma warning(push)
#pragma warning(disable: 4996)	// was declared deprecated
template<class _Ty>
	struct _Get_size_type<_Ty, void_t<typename _Ty::size_type>>
	{	// get _Ty::size_type
	using type = typename _Ty::size_type;
	};
#pragma warning(pop)

		// STRUCT TEMPLATE _Get_propagate_on_container_copy
template<class _Ty,
	class = void>
	struct _Get_propagate_on_container_copy
	{	// provide fallback
	using type = false_type;
	};

template<class _Ty>
	struct _Get_propagate_on_container_copy<_Ty, void_t<typename _Ty::propagate_on_container_copy_assignment>>
	{	// get _Ty::propagate_on_container_copy_assignment
	using type = typename _Ty::propagate_on_container_copy_assignment;
	};

		// STRUCT TEMPLATE _Get_propagate_on_container_move
template<class _Ty,
	class = void>
	struct _Get_propagate_on_container_move
	{	// provide fallback
	using type = false_type;
	};

template<class _Ty>
	struct _Get_propagate_on_container_move<_Ty, void_t<typename _Ty::propagate_on_container_move_assignment>>
	{	// get _Ty::propagate_on_container_move_assignment
	using type = typename _Ty::propagate_on_container_move_assignment;
	};

		// STRUCT TEMPLATE _Get_propagate_on_container_swap
template<class _Ty,
	class = void>
	struct _Get_propagate_on_container_swap
	{	// provide fallback
	using type = false_type;
	};

template<class _Ty>
	struct _Get_propagate_on_container_swap<_Ty, void_t<typename _Ty::propagate_on_container_swap>>
	{	// get _Ty::propagate_on_container_swap
	using type = typename _Ty::propagate_on_container_swap;
	};

		// STRUCT TEMPLATE _Get_is_always_equal
template<class _Ty,
	class = void>
	struct _Get_is_always_equal
	{	// provide fallback
	using type = typename is_empty<_Ty>::type;
	};

template<class _Ty>
	struct _Get_is_always_equal<_Ty, void_t<typename _Ty::is_always_equal>>
	{	// get _Ty::is_always_equal
	using type = typename _Ty::is_always_equal;
	};

		// STRUCT TEMPLATE _Get_rebind_type
template<class _Ty,
	class _Other,
	class = void>
	struct _Get_rebind_type
	{	// provide fallback
	using type = typename _Replace_first_parameter<_Other, _Ty>::type;
	};

#pragma warning(push)
#pragma warning(disable: 4996)	// was declared deprecated
template<class _Ty,
	class _Other>
	struct _Get_rebind_type<_Ty, _Other, void_t<typename _Ty::template rebind<_Other>::other>>
	{	// get _Ty::rebind<_Other>::other
	using type = typename _Ty::template rebind<_Other>::other;
	};
#pragma warning(pop)

		// STRUCT TEMPLATE _Is_default_allocator
template<class _Ty>
	class allocator;

template<class _Alloc,
	class = void>
	struct _Is_default_allocator
		: false_type
	{	// tests whether _Alloc is non-specialized default allocator (N4659 23.10.9 [default.allocator])
	};

template<class _Ty>
	struct _Is_default_allocator<allocator<_Ty>, typename allocator<_Ty>::_Not_user_specialized>
		: true_type
	{	// tests whether _Alloc is non-specialized default allocator (N4659 23.10.9 [default.allocator])
	};

		// ALIAS TEMPLATES _Uses_default_construct AND _Uses_default_construct_t
struct _Has_no_alloc_construct_tag
	{	// TRANSITION, C1XX
	};

template<class _Void,
	class... _Types>
	struct _Has_no_alloc_construct
		: true_type
	{	// determines whether _Alloc has no construct
	};

#pragma warning(push)
#pragma warning(disable: 4996)	// was declared deprecated
template<class _Alloc,
	class _Ptr,
	class... _Args>
	struct _Has_no_alloc_construct<
		void_t<
			_Has_no_alloc_construct_tag,
			decltype(_STD declval<_Alloc&>().construct(_STD declval<_Ptr>(), _STD declval<_Args>()...))>,
		_Alloc, _Ptr, _Args...>
		: false_type
	{	// determines whether _Alloc has no construct
	};
#pragma warning(pop)

template<class _Alloc,
	class _Ptr,
	class... _Args>
	using _Uses_default_construct = disjunction<
		_Is_default_allocator<_Alloc>,
		_Has_no_alloc_construct<void, _Alloc, _Ptr, _Args...>>;

template<class _Alloc,
	class _Ptr,
	class... _Args>
	using _Uses_default_construct_t = typename _Uses_default_construct<_Alloc, _Ptr, _Args...>::type;


		// ALIAS TEMPLATE _Uses_default_destroy AND _Uses_default_destroy_t
struct _Has_no_alloc_destroy_tag
	{	// TRANSITION, C1XX
	};

template<class _Alloc,
	class _Ptr,
	class = void>
	struct _Has_no_alloc_destroy
		: true_type
	{	// determines whether _Alloc has no destroy
	};

#pragma warning(push)
#pragma warning(disable: 4996)	// was declared deprecated
template<class _Alloc,
	class _Ptr>
	struct _Has_no_alloc_destroy<_Alloc, _Ptr, void_t<
			_Has_no_alloc_destroy_tag,
			decltype(_STD declval<_Alloc&>().destroy(_STD declval<_Ptr>()))>>
		: false_type
	{	// determines whether _Alloc has no destroy
	};
#pragma warning(pop)

template<class _Alloc,
	class _Ptr>
	using _Uses_default_destroy = disjunction<
		_Is_default_allocator<_Alloc>,
		_Has_no_alloc_destroy<_Alloc, _Ptr>>;

template<class _Alloc,
	class _Ptr>
	using _Uses_default_destroy_t = typename _Uses_default_destroy<_Alloc, _Ptr>::type;


		// STRUCT TEMPLATE _Has_allocate_hint
struct _Has_allocate_hint_tag
	{	// TRANSITION, C1XX
	};

template<class _Alloc,
	class _Size_type,
	class _Const_void_pointer,
	class = void>
	struct _Has_allocate_hint
		: false_type
	{	// determines whether _Alloc has allocate(n, hint)
	};

#pragma warning(push)
#pragma warning(disable: 4996)	// was declared deprecated
template<class _Alloc,
	class _Size_type,
	class _Const_void_pointer>
	struct _Has_allocate_hint<_Alloc, _Size_type, _Const_void_pointer, void_t<
			_Has_allocate_hint_tag,
			decltype(_STD declval<_Alloc&>().allocate(
				_STD declval<const _Size_type&>(), _STD declval<const _Const_void_pointer&>()))>>
		: true_type
	{	// determines whether _Alloc has allocate(n, hint)
	};
#pragma warning(pop)

		// STRUCT TEMPLATE _Has_max_size
struct _Has_max_size_tag
	{	// TRANSITION, C1XX
	};

template<class _Alloc,
	class = void>
	struct _Has_max_size
		: false_type
	{	// determines whether _Alloc has max_size()
	};

#pragma warning(push)
#pragma warning(disable: 4996)	// was declared deprecated
template<class _Alloc>
	struct _Has_max_size<_Alloc, void_t<
			_Has_max_size_tag,
			decltype(_STD declval<const _Alloc&>().max_size())>>
		: true_type
	{	// determines whether _Alloc has max_size()
	};
#pragma warning(pop)

		// STRUCT TEMPLATE _Has_select_on_container_copy_construction
struct _Has_select_on_container_copy_construction_tag
	{	// TRANSITION, C1XX
	};

template<class _Alloc,
	class = void>
	struct _Has_select_on_container_copy_construction
		: false_type
	{	// determines whether _Alloc has select_on_container_copy_construction()
	};

template<class _Alloc>
	struct _Has_select_on_container_copy_construction<_Alloc, void_t<
			_Has_select_on_container_copy_construction_tag,
			decltype(_STD declval<const _Alloc&>().select_on_container_copy_construction())>>
		: true_type
	{	// determines whether _Alloc has select_on_container_copy_construction()
	};


		// STRUCT TEMPLATE allocator_traits
template<class _Alloc>
	struct allocator_traits;

#pragma warning(push)
#pragma warning(disable: 4996)	// was declared deprecated
template<class _Alloc>
	struct _Normal_allocator_traits
	{	// defines traits for allocators
	using allocator_type = _Alloc;
	using value_type = typename _Alloc::value_type;

	using pointer = typename _Get_pointer_type<_Alloc>::type;
	using const_pointer = typename _Get_const_pointer_type<_Alloc>::type;
	using void_pointer = typename _Get_void_pointer_type<_Alloc>::type;
	using const_void_pointer = typename _Get_const_void_pointer_type<_Alloc>::type;

	using size_type = typename _Get_size_type<_Alloc>::type;
	using difference_type = typename _Get_difference_type<_Alloc>::type;

	using propagate_on_container_copy_assignment = typename _Get_propagate_on_container_copy<_Alloc>::type;
	using propagate_on_container_move_assignment = typename _Get_propagate_on_container_move<_Alloc>::type;
	using propagate_on_container_swap = typename _Get_propagate_on_container_swap<_Alloc>::type;
	using is_always_equal = typename _Get_is_always_equal<_Alloc>::type;

	template<class _Other>
		using rebind_alloc = typename _Get_rebind_type<_Alloc, _Other>::type;

	template<class _Other>
		using rebind_traits = allocator_traits<rebind_alloc<_Other>>;

	static _DECLSPEC_ALLOCATOR pointer allocate(_Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count)
		{	// allocate array of _Count elements
		return (_Al.allocate(_Count));
		}

	static _DECLSPEC_ALLOCATOR pointer _Allocate1(_Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count,
		const const_void_pointer _Hint, true_type)
		{	// allocate array of _Count elements, with hint, allocator-supplied version
		return (_Al.allocate(_Count, _Hint));
		}

	static _DECLSPEC_ALLOCATOR pointer _Allocate1(_Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count,
		const_void_pointer, false_type)
		{	// allocate array of _Count elements, with hint, default version
		return (_Al.allocate(_Count));
		}

	static _DECLSPEC_ALLOCATOR pointer allocate(_Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count,
		const const_void_pointer _Hint)
		{	// allocate array of _Count elements, with hint
		return (_Allocate1(_Al, _Count, _Hint, _Has_allocate_hint<_Alloc, size_type, const_void_pointer>{}));
		}

	static void deallocate(_Alloc& _Al, pointer _Ptr, size_type _Count)
		{	// deallocate _Count elements at _Ptr
		_Al.deallocate(_Ptr, _Count);
		}

	template<class _Ty,
		class... _Types>
		static void _Construct1(true_type, _Alloc&, _Ty *_Ptr, _Types&&... _Args)
		{	// construct _Ty(_Types...) at _Ptr, default version
		::new (static_cast<void *>(_Ptr)) _Ty(_STD forward<_Types>(_Args)...);
		}

	template<class _Ty,
		class... _Types>
		static void _Construct1(false_type, _Alloc& _Al, _Ty *_Ptr, _Types&&... _Args)
		{	// construct _Ty(_Types...) at _Ptr, allocator-supplied version
		_Al.construct(_Ptr, _STD forward<_Types>(_Args)...);
		}

	template<class _Ty,
		class... _Types>
		static void construct(_Alloc& _Al, _Ty *_Ptr, _Types&&... _Args)
		{	// construct _Ty(_Types...) at _Ptr
		_Construct1(_Uses_default_construct_t<_Alloc, _Ty *, _Types...>(),
			_Al, _Ptr, _STD forward<_Types>(_Args)...);
		}

	template<class _Ty>
		static void _Destroy1(_Alloc&, _Ty *_Ptr, true_type)
		{	// destroy object at _Ptr, default version
		_Ptr->~_Ty();
		}

	template<class _Ty>
		static void _Destroy1(_Alloc& _Al, _Ty *_Ptr, false_type)
		{	// destroy object at _Ptr, allocator-supplied version
		_Al.destroy(_Ptr);
		}

	template<class _Ty>
		static void destroy(_Alloc& _Al, _Ty *_Ptr)
		{	// destroy object at _Ptr
		_Destroy1(_Al, _Ptr, _Uses_default_destroy_t<_Alloc, _Ty *>());
		}

	static size_type _Max_size1(const _Alloc& _Al, true_type) _NOEXCEPT
		{	// get maximum size, allocator-supplied version
		return (_Al.max_size());
		}

	static size_type _Max_size1(const _Alloc&, false_type) _NOEXCEPT
		{	// get maximum size, default version
		return ((numeric_limits<size_type>::max)() / sizeof(value_type));
		}

	static size_type max_size(const _Alloc& _Al) _NOEXCEPT
		{	// get maximum size
		return (_Max_size1(_Al, _Has_max_size<_Alloc>{}));
		}

	static _Alloc _Select_on_container_copy_construction1(const _Alloc& _Al, true_type)
		{	// get allocator to use, allocator-supplied version
		return (_Al.select_on_container_copy_construction());
		}

	static _Alloc _Select_on_container_copy_construction1(const _Alloc& _Al, false_type)
		{	// get allocator to use, default version
		return (_Al);
		}

	static _Alloc select_on_container_copy_construction(const _Alloc& _Al)
		{	// get allocator to use
		return (_Select_on_container_copy_construction1(_Al, _Has_select_on_container_copy_construction<_Alloc>{}));
		}
	};
#pragma warning(pop)

template<class _Alloc>
	struct _Default_allocator_traits
	{	// traits for std::allocator
	using allocator_type = _Alloc;
	using value_type = typename _Alloc::value_type;

	using pointer = value_type *;
	using const_pointer = const value_type *;
	using void_pointer = void *;
	using const_void_pointer = const void *;

	using size_type = size_t;
	using difference_type = ptrdiff_t;

	using propagate_on_container_copy_assignment = false_type;
	using propagate_on_container_move_assignment = true_type;
	using propagate_on_container_swap = false_type;
	using is_always_equal = true_type;

	template<class _Other>
		using rebind_alloc = allocator<_Other>;

	template<class _Other>
		using rebind_traits = allocator_traits<allocator<_Other>>;

	static _DECLSPEC_ALLOCATOR pointer allocate(_Alloc&, _CRT_GUARDOVERFLOW const size_type _Count)
		{	// allocate array of _Count elements
		return (static_cast<pointer>(_Allocate(_Count, sizeof(value_type), alignof(value_type))));
		}

	static _DECLSPEC_ALLOCATOR pointer allocate(_Alloc&, _CRT_GUARDOVERFLOW const size_type _Count,
		const_void_pointer)
		{	// allocate array of _Count elements, with hint
		return (static_cast<pointer>(_Allocate(_Count, sizeof(value_type), alignof(value_type))));
		}

	static void deallocate(_Alloc&, const pointer _Ptr, const size_type _Count)
		{	// deallocate _Count elements at _Ptr
		_Deallocate(_Ptr, _Count, sizeof(value_type), alignof(value_type));
		}

	template<class _Objty,
		class... _Types>
		static void construct(_Alloc&, _Objty * const _Ptr, _Types&&... _Args)
		{	// construct _Objty(_Types...) at _Ptr
		::new (const_cast<void *>(static_cast<const volatile void *>(_Ptr)))
			_Objty(_STD forward<_Types>(_Args)...);
		}

	template<class _Uty>
		static void destroy(_Alloc&, _Uty * const _Ptr)
		{	// destroy object at _Ptr
		_Ptr->~_Uty();
		}

	static size_type max_size(const _Alloc&) _NOEXCEPT
		{	// get maximum size
		return (static_cast<size_t>(-1) / sizeof(value_type));
		}

	static _Alloc select_on_container_copy_construction(const _Alloc& _Al)
		{	// get allocator to use
		return (_Al);
		}
	};

template<class _Alloc>
	struct allocator_traits
		: conditional_t<_Is_default_allocator<_Alloc>::value,
			_Default_allocator_traits<_Alloc>, _Normal_allocator_traits<_Alloc>>
	{	// defines traits for allocators
	};

		// ALIAS TEMPLATE _Rebind_alloc_t
template<class _Alloc,
	class _Value_type>
	using _Rebind_alloc_t = typename allocator_traits<_Alloc>::template rebind_alloc<_Value_type>;

		// VARIABLE TEMPLATE _Is_simple_alloc_v
template<class _Alloc>	// tests if allocator has simple addressing
	_INLINE_VAR constexpr bool _Is_simple_alloc_v =
		is_same_v<typename allocator_traits<_Alloc>::size_type, size_t>
		&& is_same_v<typename allocator_traits<_Alloc>::difference_type, ptrdiff_t>
		&& is_same_v<typename allocator_traits<_Alloc>::pointer, typename _Alloc::value_type *>
		&& is_same_v<typename allocator_traits<_Alloc>::const_pointer, const typename _Alloc::value_type *>;

		// STRUCT TEMPLATE _Simple_types
template<class _Value_type>
	struct _Simple_types
	{	// wraps types from allocators with simple addressing for use in iterators
		// and other SCARY machinery
	using value_type = _Value_type;
	using size_type = size_t;
	using difference_type = ptrdiff_t;
	using pointer = value_type *;
	using const_pointer = const value_type *;
	};

		// CLASS TEMPLATE allocator
template<class _Ty>
	class allocator
	{	// generic allocator for objects of class _Ty
public:
	static_assert(!is_const_v<_Ty>,
		"The C++ Standard forbids containers of const elements "
		"because allocator<const T> is ill-formed.");

	using _Not_user_specialized = void;

	using value_type = _Ty;

	_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS typedef _Ty * pointer;
	_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS typedef const _Ty * const_pointer;

	_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS typedef _Ty& reference;
	_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS typedef const _Ty& const_reference;

	_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS typedef size_t size_type;
	_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS typedef ptrdiff_t difference_type;

	using propagate_on_container_move_assignment = true_type;
	using is_always_equal = true_type;

	template<class _Other>
		struct _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS rebind
		{	// convert this type to allocator<_Other>
		using other = allocator<_Other>;
		};

	_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _Ty * address(_Ty& _Val) const _NOEXCEPT
		{	// return address of mutable _Val
		return (_STD addressof(_Val));
		}

	_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS const _Ty * address(const _Ty& _Val) const _NOEXCEPT
		{	// return address of nonmutable _Val
		return (_STD addressof(_Val));
		}

	allocator() _NOEXCEPT
		{	// construct default allocator (do nothing)
		}

	allocator(const allocator&) _NOEXCEPT = default;
	template<class _Other>
		allocator(const allocator<_Other>&) _NOEXCEPT
		{	// construct from a related allocator (do nothing)
		}

	void deallocate(_Ty * const _Ptr, const size_t _Count)
		{	// deallocate object at _Ptr
		_Deallocate(_Ptr, _Count, sizeof(_Ty), alignof(_Ty));
		}

	_DECLSPEC_ALLOCATOR _Ty * allocate(_CRT_GUARDOVERFLOW const size_t _Count)
		{	// allocate array of _Count elements
		return (static_cast<_Ty *>(_Allocate(_Count, sizeof(_Ty), alignof(_Ty))));
		}

	_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _DECLSPEC_ALLOCATOR _Ty * allocate(
		_CRT_GUARDOVERFLOW const size_t _Count, const void *)
		{	// allocate array of _Count elements, ignore hint
		return (allocate(_Count));
		}

	template<class _Objty,
		class... _Types>
		_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS void construct(_Objty * const _Ptr, _Types&&... _Args)
		{	// construct _Objty(_Types...) at _Ptr
		::new (const_cast<void *>(static_cast<const volatile void *>(_Ptr)))
			_Objty(_STD forward<_Types>(_Args)...);
		}

	template<class _Uty>
		_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS void destroy(_Uty * const _Ptr)
		{	// destroy object at _Ptr
		_Ptr->~_Uty();
		}

	_CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS size_t max_size() const _NOEXCEPT
		{	// estimate maximum array size
		return (static_cast<size_t>(-1) / sizeof(_Ty));
		}
	};

		// CLASS allocator<void>
template<>
	class _CXX17_DEPRECATE_ALLOCATOR_VOID allocator<void>
	{	// generic allocator for type void
public:
	using value_type = void;
	using pointer = void *;
	using const_pointer = const void *;

	template<class _Other>
		struct rebind
		{	// convert this type to an allocator<_Other>
		using other = allocator<_Other>;
		};
	};

template<class _Ty,
	class _Other> inline
	bool operator==(const allocator<_Ty>&,
		const allocator<_Other>&) _NOEXCEPT
	{	// test for allocator equality
	return (true);
	}

template<class _Ty,
	class _Other> inline
	bool operator!=(const allocator<_Ty>&,
		const allocator<_Other>&) _NOEXCEPT
	{	// test for allocator inequality
	return (false);
	}

		// FUNCTION TEMPLATE _Pocca
template<class _Alloc> inline
	void _Pocca(_Alloc& _Left, const _Alloc& _Right, true_type) _NOEXCEPT
	{	// propagate on container copy assignment
	_Left = _Right;
	}

template<class _Alloc> inline
	void _Pocca(_Alloc&, const _Alloc&, false_type) _NOEXCEPT
	{	// (don't) propagate on container copy assignment
	}

template<class _Alloc> inline
	void _Pocca(_Alloc& _Left, const _Alloc& _Right) _NOEXCEPT
	{	// (maybe) propagate on container copy assignment
	typename allocator_traits<_Alloc>::propagate_on_container_copy_assignment _Tag;
	_Pocca(_Left, _Right, _Tag);
	}

		// FUNCTION TEMPLATE _Pocma
template<class _Alloc> inline
	void _Pocma(_Alloc& _Left, _Alloc& _Right, true_type) _NOEXCEPT
	{	// propagate on container move assignment
	_Left = _STD move(_Right);
	}

template<class _Alloc> inline
	void _Pocma(_Alloc&, _Alloc&, false_type) _NOEXCEPT
	{	// (don't) propagate on container move assignment
	}

template<class _Alloc> inline
	void _Pocma(_Alloc& _Left, _Alloc& _Right) _NOEXCEPT
	{	// (maybe) propagate on container move assignment
	typename allocator_traits<_Alloc>::propagate_on_container_move_assignment _Tag;
	_Pocma(_Left, _Right, _Tag);
	}

		// FUNCTION TEMPLATE _Pocs
template<class _Alloc> inline
	void _Pocs(_Alloc& _Left, _Alloc& _Right, true_type) _NOEXCEPT
	{	// propagate on container swap
	_Swap_adl(_Left, _Right);
	}

template<class _Alloc> inline
	void _Pocs(_Alloc& _Left, _Alloc& _Right, false_type) _NOEXCEPT
	{	// (don't) propagate on container swap
	if (_Left != _Right)
		{	// containers are incompatible
 #if _ITERATOR_DEBUG_LEVEL == 2
		_DEBUG_ERROR("containers incompatible for swap");
 #else /* ITERATOR_DEBUG_LEVEL == 2 */
		_STD terminate();
 #endif /* ITERATOR_DEBUG_LEVEL == 2 */
		}
	}

template<class _Alloc> inline
	void _Pocs(_Alloc& _Left, _Alloc& _Right) _NOEXCEPT
	{	// (maybe) propagate on container swap
	typename allocator_traits<_Alloc>::propagate_on_container_swap _Tag;
	_Pocs(_Left, _Right, _Tag);
	}


		// FUNCTION TEMPLATE _Destroy_range WITH ALLOC
template<class _Alloc> inline
	void _Destroy_range1(
		typename allocator_traits<_Alloc>::pointer _First,
		typename allocator_traits<_Alloc>::pointer _Last,
		_Alloc& _Al, false_type)
	{	// destroy [_First, _Last), no special optimization
	for (; _First != _Last; ++_First)
		{
		allocator_traits<_Alloc>::destroy(_Al, _Unfancy(_First));
		}
	}

template<class _Alloc> inline
	void _Destroy_range1(
		typename allocator_traits<_Alloc>::pointer,
		typename allocator_traits<_Alloc>::pointer,
		_Alloc&, true_type)
	{	// destroy [_First, _Last), trivially destructible and default destroy
		// nothing to do
	}

template<class _Alloc> inline
	void _Destroy_range(
		typename allocator_traits<_Alloc>::pointer _First,
		typename allocator_traits<_Alloc>::pointer _Last,
		_Alloc& _Al)
	{	// destroy [_First, _Last), choose optimization
		// note that this is an optimization for debug mode codegen;
		// in release mode the BE removes all of this
	using _Val = typename _Alloc::value_type;
	_Destroy_range1(_First, _Last, _Al, _Conjunction_t<
		is_trivially_destructible<_Val>,
		_Uses_default_destroy<_Alloc, _Val *>>());
	}


		// FUNCTION TEMPLATE _Destroy_range
template<class _FwdIt> inline
	void _Destroy_range1(_FwdIt _First, _FwdIt _Last, false_type)
	{	// destroy [_First, _Last), no special optimization
	for (; _First != _Last; ++_First)
		{
		_Destroy_in_place(*_First);
		}
	}

template<class _FwdIt> inline
	void _Destroy_range1(_FwdIt, _FwdIt, true_type)
	{	// destroy [_First, _Last), trivially destructible
		// nothing to do
	}

template<class _FwdIt> inline
	void _Destroy_range(_FwdIt _First, _FwdIt _Last)
	{	// destroy [_First, _Last), choose optimization
		// note that this is an optimization for debug mode codegen;
		// in release mode the BE removes all of this
	_Destroy_range1(_First, _Last, is_trivially_destructible<_Iter_value_t<_FwdIt>>());
	}


		// FUNCTION TEMPLATE _Convert_size
template<class _Size_type> inline
	_Size_type _Convert_size(const size_t _Len)
	{	// convert size_t to _Size_type, avoiding truncation
	if (_Len > (numeric_limits<_Size_type>::max)())
		{
		_Xlength_error("size_t too long for _Size_type");
		}

	return (static_cast<_Size_type>(_Len));
	}

template<> inline
	size_t _Convert_size<size_t>(const size_t _Len)
	{	// convert size_t to size_t, unchanged
	return (_Len);
	}

		// FUNCTION TEMPLATES FOR CHECKING/UNCHECKING PAIRS
template<class _Iter1,
	class _Iter2,
	class _UIter1,
	class _UIter2>
	constexpr pair<_Iter1, _Iter2>
		_Rechecked_both(_Iter1 _Dest1, _Iter2 _Dest2, pair<_UIter1, _UIter2> _Src)
	{	// reset checked from unchecked, generic
	return {_Rechecked(_Dest1, _Src.first), _Rechecked(_Dest2, _Src.second)};
	}

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _Iter1,
	class _Iter2,
	class _UIter1>
	constexpr pair<_Iter1, _Iter2> _Rechecked_first(_Iter1 _Dest1, pair<_UIter1, _Iter2> _Src)
	{	// reset only the first checked from unchecked
	return {_Rechecked(_Dest1, _Src.first), _Src.second};
	}

template<class _Iter1,
	class _Iter2,
	class _UIter2>
	constexpr pair<_Iter1, _Iter2> _Rechecked_second(_Iter2 _Dest2, pair<_Iter1, _UIter2> _Src)
	{	// reset only the second checked from unchecked
	return {_Src.first, _Rechecked(_Dest2, _Src.second)};
	}

template<class _Iter1,
	class _Iter2> inline
	pair<_Unchecked_t<_Iter1>, _Unchecked_t<_Iter2>> _Unchecked_both(pair<_Iter1, _Iter2> _Src)
	{	// unchecks iterators in a pair (for _ITERATOR_DEBUG_ARRAY_OVERLOADS)
	return {_Unchecked(_Src.first), _Unchecked(_Src.second)};
	}

template<class _Iter1,
	class _Iter2> inline
	pair<_Unchecked_t<_Iter1>, _Iter2> _Unchecked_first(pair<_Iter1, _Iter2> _Src)
	{	// unchecks first in a pair (for _ITERATOR_DEBUG_ARRAY_OVERLOADS)
	return {_Unchecked(_Src.first), _Src.second};
	}

template<class _Iter1,
	class _Iter2> inline
	pair<_Iter1, _Unchecked_t<_Iter2>> _Unchecked_second(pair<_Iter1, _Iter2> _Src)
	{	// unchecks second in a pair (for _ITERATOR_DEBUG_ARRAY_OVERLOADS)
	return {_Src.first, _Unchecked(_Src.second)};
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

		// FUNCTION TEMPLATE _Deallocate_plain
template<class _Alloc,
	enable_if_t<is_same_v<typename allocator_traits<_Alloc>::pointer,
		typename _Alloc::value_type *>, int> = 0> inline
	void _Deallocate_plain(_Alloc& _Al, typename _Alloc::value_type * const _Ptr)
	{	// deallocate a plain pointer using an allocator, non-fancy pointers special case
	allocator_traits<_Alloc>::deallocate(_Al, _Ptr, 1);
	}

template<class _Alloc,
	enable_if_t<!is_same_v<typename allocator_traits<_Alloc>::pointer,
		typename _Alloc::value_type *>, int> = 0> inline
	void _Deallocate_plain(_Alloc& _Al, typename _Alloc::value_type * const _Ptr)
	{	// deallocate a plain pointer using an allocator
	using _Alloc_traits = allocator_traits<_Alloc>;
	using _Ptr_traits = pointer_traits<typename _Alloc_traits::pointer>;
	_Alloc_traits::deallocate(_Al, _Ptr_traits::pointer_to(*_Ptr), 1);
	}
_STD_END

		// ATOMIC REFERENCE COUNTING PRIMITIVES
  #include <xatomic0.h>

  #if _USE_INTERLOCKED_REFCOUNTING
   #include <intrin0.h>

   #define _MT_INCR(x) \
	_InterlockedIncrement(reinterpret_cast<volatile long *>(&x))
   #define _MT_DECR(x) \
	_InterlockedDecrement(reinterpret_cast<volatile long *>(&x))

  #else /* _USE_INTERLOCKED_REFCOUNTING */
   #include <xatomic.h>

   #define _MT_INCR(x) \
	_Inc_atomic_counter_explicit(x, memory_order_relaxed)
   #define _MT_DECR(x) \
	_Dec_atomic_counter_explicit(x, memory_order_acq_rel)
  #endif /* _USE_INTERLOCKED_REFCOUNTING */

 #pragma pop_macro("new")
 #pragma warning(pop)
 #pragma pack(pop)
#endif /* RC_INVOKED */
#endif /* _XMEMORY0_ */

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