xutility File Reference

#include <climits>
#include <cstdlib>
#include <utility>

Classes
struct	_Container_base0
struct	_Iterator_base0
struct	_Container_proxy
struct	_Container_base12
struct	_Iterator_base12
struct	_Zero_then_variadic_args_t
struct	_One_then_variadic_args_t
class	_Compressed_pair< _Ty1, _Ty2, bool >
class	_Compressed_pair< _Ty1, _Ty2, false >
struct	_Is_checked_helper< _Ty, class >
struct	_Is_checked_helper< _Ty, void_t< typename _Ty::_Unchecked_type > >
struct	input_iterator_tag
struct	_Mutable_iterator_tag
struct	output_iterator_tag
struct	forward_iterator_tag
struct	bidirectional_iterator_tag
struct	random_access_iterator_tag
struct	_General_ptr_iterator_tag
struct	_Trivially_copyable_ptr_iterator_tag
struct	_Really_trivial_ptr_iterator_tag
struct	_Any_tag
struct	iterator< _Category, _Ty, _Diff, _Pointer, _Reference >
struct	_Iterator012< _Category, _Ty, _Diff, _Pointer, _Reference, _Base >
struct	_Iterator_traits_base< class, class >
struct	_Iterator_traits_base< _Iter, void_t< typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type, typename _Iter::pointer, typename _Iter::reference > >
struct	iterator_traits< _Iter >
struct	iterator_traits< _Ty * >
struct	iterator_traits< const _Ty * >
struct	_Is_iterator< _Ty, class >
struct	_Is_iterator< _Ty, void_t< typename iterator_traits< _Ty >::iterator_category > >
struct	_Distance_unknown
struct	_Is_same_size< _Ty1, _Ty2 >
struct	_Unwrap_enum< _Elem, _Is_enum >
struct	_Unwrap_enum< _Elem, false >
struct	_Both_or_neither_bool< _Ty1, _Ty2 >
struct	_Ptr_cat_helper< _Source, _Dest >
struct	_Ptr_cat_helper< _Elem, _Elem >
struct	_Ptr_cat_helper< _Anything *, const _Anything * >
struct	pointer_traits< _Ty >
class	reverse_iterator< _RanIt >
struct	_Is_checked_helper< reverse_iterator< _RanIt > >
class	_Array_const_iterator< _Ty, _Size >
class	_Array_iterator< _Ty, _Size >
class	move_iterator< _RanIt >
struct	_Is_checked_helper< move_iterator< _RanIt > >
struct	_Char_traits_eq< _Traits >
struct	_Char_traits_lt< _Traits >
struct	_Is_character< _Ty >
struct	_Is_character< char >
struct	_Is_character< signed char >
struct	_Is_character< unsigned char >
struct	_Fill_memset_is_safe_helper< _FwdIt, _Ty >
struct	_Value_equality_is_bitwise_equality< _Elem1, _Elem2 >
struct	_Equal_memcmp_is_safe_helper< _Elem1, _Elem2, _Pr >
struct	_Equal_memcmp_is_safe_helper< _Elem1, _Elem2, equal_to<> >
struct	_Equal_memcmp_is_safe_helper< _Elem1 *, _Elem2 *, equal_to<> >
struct	_Equal_memcmp_is_safe_helper< _Elem, _Elem, _Char_traits_eq< char_traits< _Elem > > >
struct	_Equal_memcmp_is_safe_helper< _Elem, _Elem, equal_to< _Elem > >
struct	_Lex_compare_check_element_types_helper< _Elem1, _Elem2, _FTy >
struct	_Lex_compare_check_element_types_helper< _Elem1, _Elem2, void >
struct	_Lex_compare_optimize< _Memcmp_pr >
class	_Rng_from_urng< _Diff, _Urng >
class	_Yarn< _Elem >
class	back_insert_iterator< _Container >
struct	_Is_checked_helper< back_insert_iterator< _Container > >
struct	_Has_allocator_type< _Ty, _Alloc, class >
struct	_Has_allocator_type< _Ty, _Alloc, void_t< typename _Ty::allocator_type > >
struct	allocator_arg_t
struct	std::uses_allocator< _Ty, _Alloc >

Macros
#define	_XUTILITY_
#define	_DEBUG_ERROR(mesg)
#define	_IDL_VERIFY(assertion, message)
#define	_IDL_VERIFY_ALWAYS(assertion, message)   _SCL_SECURE_ALWAYS_VALIDATE(assertion)
#define	_UNCHECKED_TYPE(_Iter)   decltype(_Unchecked(_STD declval<_Iter>()))
#define	_DEFINE_DEPRECATE_UNCHECKED(_Func)
#define	_USE_DEPRECATE_UNCHECKED(_Iter)   (_Unchecked_iterators::_Deprecate(_Is_checked(_Iter)))
#define	_DEPRECATE_UNCHECKED(_Func, _Iter)
#define	_DEBUG_LT(x, y)   ((x) < (y))
#define	_DEBUG_LT_PRED(pred, x, y)   pred(x, y)
#define	_DEBUG_ORDER_PRED(first, last, pred)
#define	_DEBUG_RANGE(first, last)
#define	_DEBUG_RANGE2(first, last, file, line)
#define	_DEBUG_ARRAY_SIZE(_Array, _Desired)

Typedefs
typedef _Container_base0	_Container_base
typedef _Iterator_base0	_Iterator_base
typedef iterator< output_iterator_tag, void, void, void, void >	_Outit
template<class _Iter >
using	_Iter_value_t = typename iterator_traits< _Iter >::value_type
template<class _Iter >
using	_Iter_diff_t = typename iterator_traits< _Iter >::difference_type
template<class _Iter >
using	_Iter_cat_t = typename iterator_traits< _Iter >::iterator_category
template<class _Memcmp_pr , class _Obj1 , class _Obj2 , class _FTy >
using	_Lex_compare_check_element_types = _Lex_compare_optimize< conditional_t< _Lex_compare_check_element_types_helper< remove_const_t< _Obj1 >, remove_const_t< _Obj2 >, _FTy >::value, _Memcmp_pr, void >>

Functions
template<class _Iter >
constexpr _Iter	_Unchecked (_Iter _Src)
template<class _Iter , class _UIter >
_CONSTEXPR14 _Iter &	_Rechecked (_Iter &_Dest, _UIter _Src)
template<class _Iter >
_Distance_unknown	_Idl_distance (const _Iter &, const _Iter &)
template<class _Iter , class _Diff >
auto	_Unchecked_n (_Iter _Src, _Diff)
template<class _Iter , class _Diff >
auto	_Unchecked_n_backward (_Iter _Src, _Diff)
template<class _Source , class _Dest >
_General_ptr_iterator_tag	_Ptr_copy_cat (const _Source &, const _Dest &)
template<class _Source , class _Dest >
conditional_t< is_trivially_assignable< _Dest &, _Source & >::value, typename _Ptr_cat_helper< remove_const_t< _Source >, _Dest >::type, _General_ptr_iterator_tag >	_Ptr_copy_cat (_Source *const &, _Dest *const &)
template<class _Source , class _Dest >
_General_ptr_iterator_tag	_Ptr_move_cat (const _Source &, const _Dest &)
template<class _Source , class _Dest >
conditional_t< is_trivially_assignable< _Dest &, _Source >::value, typename _Ptr_cat_helper< remove_const_t< _Source >, _Dest >::type, _General_ptr_iterator_tag >	_Ptr_move_cat (_Source *const &, _Dest *const &)
template<class _InIt , class _Diff >
void	_Advance1 (_InIt &_Where, _Diff _Off, input_iterator_tag)
template<class _BidIt , class _Diff >
void	_Advance1 (_BidIt &_Where, _Diff _Off, bidirectional_iterator_tag)
template<class _RanIt , class _Diff >
void	_Advance1 (_RanIt &_Where, _Diff _Off, random_access_iterator_tag)
template<class _InIt , class _Diff >
void	advance (_InIt &_Where, _Diff _Off)
template<class _InIt >
_Iter_diff_t< _InIt >	_Distance1 (_InIt _First, _InIt _Last, input_iterator_tag)
template<class _RanIt >
_Iter_diff_t< _RanIt >	_Distance1 (_RanIt _First, _RanIt _Last, random_access_iterator_tag)
template<class _InIt >
_Iter_diff_t< _InIt >	distance (_InIt _First, _InIt _Last)
template<class _InIt >
_InIt	next (_InIt _First, _Iter_diff_t< _InIt > _Off=1)
template<class _BidIt >
_BidIt	prev (_BidIt _First, _Iter_diff_t< _BidIt > _Off=1)
template<class _Iterator >
constexpr _Iterator	_Operator_arrow (_Iterator _Target, true_type)
template<class _Iterator >
decltype(auto) constexpr	_Operator_arrow (_Iterator &&_Target, false_type)
template<class _RanIt >
_CONSTEXPR17_11 reverse_iterator< _RanIt >	operator+ (typename reverse_iterator< _RanIt >::difference_type _Off, const reverse_iterator< _RanIt > &_Right)
template<class _RanIt1 , class _RanIt2 >
_CONSTEXPR17_11 auto	operator- (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right) -> decltype(_Right.base()-_Left.base())
template<class _RanIt1 , class _RanIt2 >
_CONSTEXPR17_11 bool	operator== (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
_CONSTEXPR17_11 bool	operator!= (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
_CONSTEXPR17_11 bool	operator< (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
_CONSTEXPR17_11 bool	operator> (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
_CONSTEXPR17_11 bool	operator<= (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
_CONSTEXPR17_11 bool	operator>= (const reverse_iterator< _RanIt1 > &_Left, const reverse_iterator< _RanIt2 > &_Right)
template<class _RanIt >
_CONSTEXPR17_11 reverse_iterator< _RanIt >	make_reverse_iterator (_RanIt _Iter)
template<class _Container >
auto	begin (_Container &_Cont) -> decltype(_Cont.begin())
template<class _Container >
auto	begin (const _Container &_Cont) -> decltype(_Cont.begin())
template<class _Container >
auto	end (_Container &_Cont) -> decltype(_Cont.end())
template<class _Container >
auto	end (const _Container &_Cont) -> decltype(_Cont.end())
template<class _Ty , size_t _Size>
constexpr _Ty *	begin (_Ty(&_Array)[_Size]) _NOEXCEPT
template<class _Ty , size_t _Size>
constexpr _Ty *	end (_Ty(&_Array)[_Size]) _NOEXCEPT
template<class _Container >
constexpr auto	cbegin (const _Container &_Cont) _NOEXCEPT_OP(_NOEXCEPT_OP(_STD begin(_Cont))) -> decltype(_STD begin(_Cont))
template<class _Container >
constexpr auto	cend (const _Container &_Cont) _NOEXCEPT_OP(_NOEXCEPT_OP(_STD end(_Cont))) -> decltype(_STD end(_Cont))
template<class _Container >
auto	rbegin (_Container &_Cont) -> decltype(_Cont.rbegin())
template<class _Container >
auto	rbegin (const _Container &_Cont) -> decltype(_Cont.rbegin())
template<class _Container >
auto	rend (_Container &_Cont) -> decltype(_Cont.rend())
template<class _Container >
auto	rend (const _Container &_Cont) -> decltype(_Cont.rend())
template<class _Ty , size_t _Size>
reverse_iterator< _Ty * >	rbegin (_Ty(&_Array)[_Size])
template<class _Ty , size_t _Size>
reverse_iterator< _Ty * >	rend (_Ty(&_Array)[_Size])
template<class _Elem >
reverse_iterator< const _Elem * >	rbegin (initializer_list< _Elem > _Ilist)
template<class _Elem >
reverse_iterator< const _Elem * >	rend (initializer_list< _Elem > _Ilist)
template<class _Container >
auto	crbegin (const _Container &_Cont) -> decltype(_STD rbegin(_Cont))
template<class _Container >
auto	crend (const _Container &_Cont) -> decltype(_STD rend(_Cont))
template<class _Container >
constexpr auto	size (const _Container &_Cont) -> decltype(_Cont.size())
template<class _Ty , size_t _Size>
constexpr size_t	size (const _Ty(&)[_Size]) _NOEXCEPT
template<class _Container >
constexpr auto	empty (const _Container &_Cont) -> decltype(_Cont.empty())
template<class _Ty , size_t _Size>
constexpr bool	empty (const _Ty(&)[_Size]) _NOEXCEPT
template<class _Elem >
constexpr bool	empty (initializer_list< _Elem > _Ilist) _NOEXCEPT
template<class _Container >
constexpr auto	data (_Container &_Cont) -> decltype(_Cont.data())
template<class _Container >
constexpr auto	data (const _Container &_Cont) -> decltype(_Cont.data())
template<class _Ty , size_t _Size>
constexpr _Ty *	data (_Ty(&_Array)[_Size]) _NOEXCEPT
template<class _Elem >
constexpr const _Elem *	data (initializer_list< _Elem > _Ilist) _NOEXCEPT
template<class _Ty , size_t _Size>
_Array_const_iterator< _Ty, _Size >::_Unchecked_type	_Unchecked (_Array_const_iterator< _Ty, _Size > _Iter)
template<class _Ty , size_t _Size>
_Array_const_iterator< _Ty, _Size > &	_Rechecked (_Array_const_iterator< _Ty, _Size > &_Iter, typename _Array_const_iterator< _Ty, _Size >::_Unchecked_type _Right)
template<class _Ty , size_t _Size>
_Array_const_iterator< _Ty, _Size >	operator+ (typename _Array_const_iterator< _Ty, _Size >::difference_type _Off, _Array_const_iterator< _Ty, _Size > _Next)
template<class _Ty , size_t _Size>
_Array_iterator< _Ty, _Size >::_Unchecked_type	_Unchecked (_Array_iterator< _Ty, _Size > _Iter)
template<class _Ty , size_t _Size>
_Array_iterator< _Ty, _Size > &	_Rechecked (_Array_iterator< _Ty, _Size > &_Iter, typename _Array_iterator< _Ty, _Size >::_Unchecked_type _Right)
template<class _Ty , size_t _Size>
_Array_iterator< _Ty, _Size >	operator+ (typename _Array_iterator< _Ty, _Size >::difference_type _Off, _Array_iterator< _Ty, _Size > _Next)
template<class _RanIt , class _Diff >
move_iterator< _RanIt >	operator+ (_Diff _Off, const move_iterator< _RanIt > &_Right)
template<class _RanIt1 , class _RanIt2 >
auto	operator- (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right) -> decltype(_Left.base()-_Right.base())
template<class _RanIt1 , class _RanIt2 >
bool	operator== (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator!= (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator< (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator> (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator<= (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt1 , class _RanIt2 >
bool	operator>= (const move_iterator< _RanIt1 > &_Left, const move_iterator< _RanIt2 > &_Right)
template<class _RanIt >
move_iterator< _RanIt >	make_move_iterator (_RanIt _Iter)
template<class _InIt , class _OutIt >
_OutIt	_Copy_memmove (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	_Copy_unchecked1 (_InIt _First, _InIt _Last, _OutIt _Dest, _General_ptr_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	_Copy_unchecked1 (_InIt _First, _InIt _Last, _OutIt _Dest, _Trivially_copyable_ptr_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	_Copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	_Copy_no_deprecate (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	copy (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	_Copy_n_unchecked2 (_InIt _First, _Diff _Count, _OutIt _Dest, input_iterator_tag)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	_Copy_n_unchecked2 (_InIt _First, _Diff _Count, _OutIt _Dest, forward_iterator_tag)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	_Copy_n_unchecked1 (_InIt _First, _Diff _Count, _OutIt _Dest, _General_ptr_iterator_tag)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	_Copy_n_unchecked1 (_InIt _First, _Diff _Count, _OutIt _Dest, _Trivially_copyable_ptr_iterator_tag)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	_Copy_n_unchecked (_InIt _First, _Diff _Count, _OutIt _Dest)
template<class _InIt , class _Diff , class _OutIt >
_OutIt	copy_n (_InIt _First, _Diff _Count, _OutIt _Dest)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	_Copy_backward_memmove (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	_Copy_backward_unchecked (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _General_ptr_iterator_tag)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	_Copy_backward_unchecked (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _Trivially_copyable_ptr_iterator_tag)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	copy_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
template<class _InIt , class _OutIt >
_OutIt	_Move_unchecked1 (_InIt _First, _InIt _Last, _OutIt _Dest, _General_ptr_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	_Move_unchecked1 (_InIt _First, _InIt _Last, _OutIt _Dest, _Trivially_copyable_ptr_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	_Move_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	_Move_no_deprecate (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	move (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	_Move_backward_unchecked1 (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _General_ptr_iterator_tag)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	_Move_backward_unchecked1 (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest, _Trivially_copyable_ptr_iterator_tag)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	_Move_backward_unchecked (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	move_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
template<class _FwdIt , class _Ty >
_Fill_memset_is_safe_helper< _FwdIt, _Ty >::type	_Fill_memset_is_safe (const _FwdIt &, const _Ty &)
template<class _FwdIt , class _Ty >
void	_Fill_unchecked1 (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, false_type)
template<class _FwdIt , class _Ty >
void	_Fill_unchecked1 (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, true_type)
template<class _FwdIt , class _Ty >
void	_Fill_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
template<class _FwdIt , class _Ty >
void	fill (_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
template<class _OutIt , class _Diff , class _Ty >
_OutIt	_Fill_n_unchecked1 (_OutIt _Dest, _Diff _Count, const _Ty &_Val, false_type)
template<class _OutIt , class _Diff , class _Ty >
_OutIt	_Fill_n_unchecked1 (_OutIt _Dest, _Diff _Count, const _Ty &_Val, true_type)
template<class _OutIt , class _Diff , class _Ty >
_OutIt	_Fill_n_unchecked (_OutIt _Dest, _Diff _Count, const _Ty &_Val)
template<class _OutIt , class _Diff , class _Ty >
_OutIt	fill_n (_OutIt _Dest, _Diff _Count, const _Ty &_Val)
template<class _Iter1 , class _Iter2 , class _Pr >
false_type	_Equal_memcmp_is_safe (const _Iter1 &, const _Iter2 &, const _Pr &)
template<class _Obj1 , class _Obj2 , class _Pr >
_Equal_memcmp_is_safe_helper< remove_const_t< _Obj1 >, remove_const_t< _Obj2 >, _Pr >::type	_Equal_memcmp_is_safe (_Obj1 *const &, _Obj2 *const &, const _Pr &)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Equal_unchecked1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred, false_type)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Equal_unchecked1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &, true_type)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Equal_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Equal_no_deprecate (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
template<class _InIt1 , class _InIt2 >
bool	equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Equal_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred, input_iterator_tag, input_iterator_tag)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Equal_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred, random_access_iterator_tag, random_access_iterator_tag)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _InIt1 , class _InIt2 >
bool	equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
template<class _InIt1 , class _InIt2 , class _Pr >
_Lex_compare_optimize< void >	_Lex_compare_memcmp_classify (const _InIt1 &, const _InIt2 &, const _Pr &)
template<class _Obj1 , class _Obj2 , class _FTy >
_Lex_compare_check_element_types< less< int >, _Obj1, _Obj2, _FTy >	_Lex_compare_memcmp_classify (_Obj1 *const &, _Obj2 *const &, const less< _FTy > &)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Lex_compare_unchecked1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred, _Lex_compare_optimize< void >)
template<class _InIt1 , class _InIt2 , class _Pr , class _Memcmp_pr >
bool	_Lex_compare_unchecked1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &, _Lex_compare_optimize< _Memcmp_pr >)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Lex_compare_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	lexicographical_compare (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _InIt1 , class _InIt2 >
bool	lexicographical_compare (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
template<class _Ty >
bool	_Within_limits (const _Ty &_Val, true_type, true_type, _Any_tag)
template<class _Ty >
bool	_Within_limits (const _Ty &_Val, true_type, false_type, true_type)
template<class _Ty >
bool	_Within_limits (const _Ty &_Val, true_type, false_type, false_type)
template<class _Ty >
bool	_Within_limits (const _Ty &_Val, false_type, true_type, _Any_tag)
template<class _Ty >
bool	_Within_limits (const _Ty &_Val, false_type, false_type, _Any_tag)
template<class _InIt , class _Ty >
bool	_Within_limits (_InIt, const _Ty &_Val)
template<class _InIt >
bool	_Within_limits (_InIt, const bool &)
template<class _InIt , class _Ty >
_InIt	_Find_unchecked1 (_InIt _First, _InIt _Last, const _Ty &_Val, true_type)
template<class _InIt , class _Ty >
_InIt	_Find_unchecked1 (_InIt _First, _InIt _Last, const _Ty &_Val, false_type)
template<class _InIt , class _Ty >
_InIt	_Find_unchecked (_InIt _First, _InIt _Last, const _Ty &_Val)
template<class _InIt , class _Ty >
_InIt	find (_InIt _First, _InIt _Last, const _Ty &_Val)
template<class _InIt , class _Ty , class _Pr >
_InIt	_Find_pr (_InIt _First, _InIt _Last, const _Ty &_Val, _Pr &_Pred)
template<class _InIt , class _Ty >
_Iter_diff_t< _InIt >	_Count_unchecked (_InIt _First, _InIt _Last, const _Ty &_Val)
template<class _InIt , class _Ty >
_Iter_diff_t< _InIt >	count (_InIt _First, _InIt _Last, const _Ty &_Val)
template<class _InIt , class _Ty , class _Pr >
_Iter_diff_t< _InIt >	_Count_pr (_InIt _First, _InIt _Last, const _Ty &_Val, _Pr &_Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
void	_Trim_matching_suffixes (_FwdIt1 &, _FwdIt2 &, _Pr &, forward_iterator_tag, forward_iterator_tag)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
void	_Trim_matching_suffixes (_FwdIt1 &_Last1, _FwdIt2 &_Last2, _Pr &_Pred, bidirectional_iterator_tag, bidirectional_iterator_tag)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool	_Check_match_counts (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool	_Is_permutation_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool	_Is_permutation_no_deprecate (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr &_Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool	is_permutation (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
bool	is_permutation (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool	_Is_permutation_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred, forward_iterator_tag, forward_iterator_tag)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool	_Is_permutation_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred, random_access_iterator_tag, random_access_iterator_tag)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
bool	is_permutation (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
bool	is_permutation (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _BidIt >
void	_Reverse_unchecked (_BidIt _First, _BidIt _Last)
template<class _BidIt >
void	reverse (_BidIt _First, _BidIt _Last)
template<class _FwdIt >
_FwdIt	_Rotate_unchecked1 (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, forward_iterator_tag)
template<class _BidIt >
pair< _BidIt, _BidIt >	_Reverse_until_sentinel_unchecked (_BidIt _First, _BidIt _Sentinel, _BidIt _Last)
template<class _BidIt >
_BidIt	_Rotate_unchecked1 (_BidIt _First, _BidIt _Mid, _BidIt _Last, bidirectional_iterator_tag)
template<class _RanIt >
_RanIt	_Rotate_unchecked1 (_RanIt _First, _RanIt _Mid, _RanIt _Last, random_access_iterator_tag)
template<class _FwdIt >
_FwdIt	_Rotate_unchecked (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
template<class _FwdIt >
_FwdIt	rotate (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
template<class _Container >
back_insert_iterator< _Container >	back_inserter (_Container &_Cont)
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	_Xbad_alloc ()
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	_Xinvalid_argument (_In_z_ const char *)
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	_Xlength_error (_In_z_ const char *)
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	_Xout_of_range (_In_z_ const char *)
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	_Xoverflow_error (_In_z_ const char *)
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL	_Xruntime_error (_In_z_ const char *)

Variables
template<class _Iter >
_Is_checked_helper< _Iter >::type	_Is_checked (_Iter)
constexpr allocator_arg_t	allocator_arg {}
template<class _Ty , class _Alloc >
constexpr bool	std::uses_allocator_v = uses_allocator<_Ty, _Alloc>::value

Macro Definition Documentation

#define _DEBUG_ARRAY_SIZE	(		_Array,
			_Desired
	)

#define _DEBUG_ERROR

(

mesg

)

#define _DEBUG_LT	(		x,
			y
	)		((x) < (y))

#define _DEBUG_LT_PRED	(		pred,
			x,
			y
	)		pred(x, y)

#define _DEBUG_ORDER_PRED	(		first,
			last,
			pred
	)

#define _DEBUG_RANGE	(		first,
			last
	)

#define _DEBUG_RANGE2	(		first,
			last,
			file,
			line
	)

#define _DEFINE_DEPRECATE_UNCHECKED

(

_Func

)

Value:

struct _Unchecked_iterators \
    {   /* Warns about unchecked iterators */ \
    static void _SCL_INSECURE_DEPRECATE_FN(_Func) _Deprecate(false_type) \
        {   /* Detected unchecked iterator, warn */ \
        } \
    \
    static void _Deprecate(true_type) \
        {   /* Detected checked iterator, do not warn */ \
        } \
    }

#define _DEPRECATE_UNCHECKED	(		_Func,
			_Iter
	)

Value:

_DEFINE_DEPRECATE_UNCHECKED(_Func); \
	_USE_DEPRECATE_UNCHECKED(_Iter)

#define _IDL_VERIFY	(		assertion,
			message
	)

#define _IDL_VERIFY_ALWAYS	(		assertion,
			message
	)		_SCL_SECURE_ALWAYS_VALIDATE(assertion)

_UNCHECKED_TYPE (   _Iter )    decltype(_Unchecked(_STD declval<_Iter>()))

inline

#define _USE_DEPRECATE_UNCHECKED

(

_Iter

)

(_Unchecked_iterators::_Deprecate(_Is_checked(_Iter)))

#define _XUTILITY_

Typedef Documentation

typedef _Container_base0 _Container_base

template<class _Iter >

using _Iter_cat_t = typename iterator_traits<_Iter>::iterator_category

template<class _Iter >

using _Iter_diff_t = typename iterator_traits<_Iter>::difference_type

template<class _Iter >

using _Iter_value_t = typename iterator_traits<_Iter>::value_type

typedef _Iterator_base0 _Iterator_base

template<class _Memcmp_pr , class _Obj1 , class _Obj2 , class _FTy >

using _Lex_compare_check_element_types = _Lex_compare_optimize<conditional_t< _Lex_compare_check_element_types_helper<remove_const_t<_Obj1>, remove_const_t<_Obj2>, _FTy>::value, _Memcmp_pr, void>>

typedef iterator<output_iterator_tag, void, void, void, void> _Outit

Function Documentation

template<class _InIt , class _Diff >

void _Advance1 ( _InIt &  _Where, _Diff  _Off, input_iterator_tag    )

inline

    {   // increment iterator by offset, input iterators
 #if _ITERATOR_DEBUG_LEVEL == 2
    if (_Off < 0)
        {
        _DEBUG_ERROR("negative offset in advance");
        }

 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

    for (; 0 < _Off; --_Off)
        ++_Where;
    }

template<class _BidIt , class _Diff >

void _Advance1 ( _BidIt &  _Where, _Diff  _Off, bidirectional_iterator_tag    )

inline

    {   // increment iterator by offset, bidirectional iterators
    for (; 0 < _Off; --_Off)
        ++_Where;
    for (; _Off < 0; ++_Off)
        --_Where;
    }

template<class _RanIt , class _Diff >

void _Advance1 ( _RanIt &  _Where, _Diff  _Off, random_access_iterator_tag    )

inline

    {   // increment iterator by offset, random-access iterators
    _Where += _Off;
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

bool _Check_match_counts ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr &  _Pred  )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, _Last2), using _Pred, same lengths
    _Trim_matching_suffixes(_Last1, _Last2, _Pred,
        _Iter_cat_t<_FwdIt1>(), _Iter_cat_t<_FwdIt2>());
    for (_FwdIt1 _Next1 = _First1; _Next1 != _Last1; ++_Next1)
        if (_Next1 == _Find_pr(_First1, _Next1, *_Next1, _Pred))
            {   // new value, compare match counts
            _Iter_diff_t<_FwdIt2> _Count2 = _Count_pr(_First2, _Last2, *_Next1, _Pred);
            if (_Count2 == 0)
                return (false); // second range lacks value, fail
            _FwdIt1 _Skip1 = _STD next(_Next1);
            _Iter_diff_t<_FwdIt1> _Count1 = _Count_pr(_Skip1, _Last1, *_Next1, _Pred) + 1;
            if (_Count2 != _Count1)
                return (false); // match counts differ, fail
            }

    return (true);
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 _Copy_backward_memmove ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest  )

inline

    {   // implement copy_backward-like function as memmove
    const char * const _First_ch = reinterpret_cast<const char *>(_First);
    const char * const _Last_ch = reinterpret_cast<const char *>(_Last);
    char * const _Dest_ch = reinterpret_cast<char *>(_Dest);
    const size_t _Count = _Last_ch - _First_ch;
    return (static_cast<_BidIt2>(
        _CSTD memmove(_Dest_ch - _Count, _First_ch, _Count)));
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 _Copy_backward_unchecked ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest, _General_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) backwards to [..., _Dest), no special optimization
    while (_First != _Last)
        *--_Dest = *--_Last;
    return (_Dest);
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 _Copy_backward_unchecked ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest, _Trivially_copyable_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) backwards to [..., _Dest), memmove optimization
    return (_Copy_backward_memmove(_First, _Last, _Dest));
    }

template<class _InIt , class _OutIt >

_OutIt _Copy_memmove ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // implement copy-like function as memmove
    const char * const _First_ch = reinterpret_cast<const char *>(_First);
    const char * const _Last_ch = reinterpret_cast<const char *>(_Last);
    char * const _Dest_ch = reinterpret_cast<char *>(_Dest);
    const size_t _Count = _Last_ch - _First_ch;
    _CSTD memmove(_Dest_ch, _First_ch, _Count);
    return (reinterpret_cast<_OutIt>(_Dest_ch + _Count));
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt _Copy_n_unchecked ( _InIt  _First, _Diff  _Count, _OutIt  _Dest  )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), choose optimization
    return (_Copy_n_unchecked1(_First, _Count,
        _Dest, _Ptr_copy_cat(_First, _Dest)));
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt _Copy_n_unchecked1 ( _InIt  _First, _Diff  _Count, _OutIt  _Dest, _General_ptr_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), no special optimization
        // note that we must dispatch on iterator power here to avoid incrementing
        // istream_iterator too many times; see LWG# 2471
    return (_Copy_n_unchecked2(_First, _Count,
        _Dest, _Iter_cat_t<_InIt>()));
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt _Copy_n_unchecked1 ( _InIt  _First, _Diff  _Count, _OutIt  _Dest, _Trivially_copyable_ptr_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), memmove optimization
    if (0 < _Count)
        return (_Copy_memmove(_First, _First + _Count, _Dest));
    return (_Dest);
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt _Copy_n_unchecked2 ( _InIt  _First, _Diff  _Count, _OutIt  _Dest, input_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), input iterators
    if (0 < _Count)
        {
        *_Dest = *_First;
        while (0 < --_Count)
            *++_Dest = *++_First;
        return (++_Dest);
        }

    return (_Dest);
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt _Copy_n_unchecked2 ( _InIt  _First, _Diff  _Count, _OutIt  _Dest, forward_iterator_tag    )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...), forward iterators
    for (; 0 < _Count; --_Count, (void)++_Dest, ++_First)
        *_Dest = *_First;
    return (_Dest);
    }

template<class _InIt , class _OutIt >

_OutIt _Copy_no_deprecate ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // copy [_First, _Last) to [_Dest, ...), no _SCL_INSECURE_DEPRECATE_FN warnings
    _DEBUG_RANGE(_First, _Last);
    const auto _UFirst = _Unchecked(_First);
    const auto _ULast = _Unchecked(_Last);
    const auto _UDest = _Unchecked_n(_Dest, _Idl_distance(_UFirst, _ULast));
    return (_Rechecked(_Dest,
        _Copy_unchecked(_UFirst, _ULast, _UDest)));
    }

template<class _InIt , class _OutIt >

_OutIt _Copy_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // copy [_First, _Last) to [_Dest, ...)
        // note: _Copy_unchecked is called directly from elsewhere in the STL
    return (_Copy_unchecked1(_First, _Last,
        _Dest, _Ptr_copy_cat(_First, _Dest)));
    }

template<class _InIt , class _OutIt >

_OutIt _Copy_unchecked1 ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _General_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to [_Dest, ...), arbitrary iterators
    for (; _First != _Last; ++_Dest, (void)++_First)
        *_Dest = *_First;
    return (_Dest);
    }

template<class _InIt , class _OutIt >

_OutIt _Copy_unchecked1 ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Trivially_copyable_ptr_iterator_tag    )

inline

    {   // copy [_First, _Last) to [_Dest, ...), pointers to trivially copyable
    return (_Copy_memmove(_First, _Last, _Dest));
    }

template<class _InIt , class _Ty , class _Pr >

_Iter_diff_t<_InIt> _Count_pr ( _InIt  _First, _InIt  _Last, const _Ty &  _Val, _Pr &  _Pred  )

inline

    {   // count elements that match _Val, using _Pred
    _Iter_diff_t<_InIt> _Count = 0;

    for (; _First != _Last; ++_First)
        if (_Pred(*_First, _Val))
            ++_Count;
    return (_Count);
    }

template<class _InIt , class _Ty >

_Iter_diff_t<_InIt> _Count_unchecked ( _InIt  _First, _InIt  _Last, const _Ty &  _Val  )

inline

    {   // count elements that match _Val
    _Iter_diff_t<_InIt> _Count = 0;

    for (; _First != _Last; ++_First)
        if (*_First == _Val)
            ++_Count;
    return (_Count);
    }

template<class _InIt >

_Iter_diff_t<_InIt> _Distance1 ( _InIt  _First, _InIt  _Last, input_iterator_tag    )

inline

    {   // return distance between iterators; input
    _Iter_diff_t<_InIt> _Off = 0;
    for (; _First != _Last; ++_First)
        ++_Off;

    return (_Off);
    }

template<class _RanIt >

_Iter_diff_t<_RanIt> _Distance1 ( _RanIt  _First, _RanIt  _Last, random_access_iterator_tag    )

inline

    {   // return distance between iterators; random-access
    return (_Last - _First);
    }

template<class _Iter1 , class _Iter2 , class _Pr >

false_type _Equal_memcmp_is_safe ( const _Iter1 &  , const _Iter2 &  , const _Pr &    )

inline

    {   // return equal optimization category for arbitrary iterators
    return {};
    }

template<class _Obj1 , class _Obj2 , class _Pr >

_Equal_memcmp_is_safe_helper< remove_const_t<_Obj1>, remove_const_t<_Obj2>, _Pr>::type _Equal_memcmp_is_safe ( _Obj1 *const &  , _Obj2 *const &  , const _Pr &    )

inline

    {   // return equal optimization category for pointers
    return {};
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Equal_no_deprecate ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr &  _Pred  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...) using _Pred, no _SCL_INSECURE_DEPRECATE_FN warnings
    _DEBUG_RANGE(_First1, _Last1);
    const auto _UFirst1 = _Unchecked(_First1);
    const auto _ULast1 = _Unchecked(_Last1);
    const auto _UFirst2 = _Unchecked_n(_First2, _Idl_distance(_UFirst1, _ULast1));
    return (_Equal_unchecked(_UFirst1, _ULast1, _UFirst2, _Pred));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Equal_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr &  _Pred  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...) using _Pred, choose optimization
    return (_Equal_unchecked1(_First1, _Last1, _First2, _Pred,
        _Equal_memcmp_is_safe(_First1, _First2, _Pred)));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Equal_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr &  _Pred, input_iterator_tag  , input_iterator_tag    )

inline

    {   // compare [_First1, _Last1) to [_First2, _Last2)
        // using _Pred, arbitrary iterators
    for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void)++_First2)
        if (!_Pred(*_First1, *_First2))
            return (false);
    return (_First1 == _Last1 && _First2 == _Last2);
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Equal_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr &  _Pred, random_access_iterator_tag  , random_access_iterator_tag    )

inline

    {   // compare [_First1, _Last1) to [_First2, _Last2)
        // using _Pred, random-access iterators
    if (_Last1 - _First1 != _Last2 - _First2)
        return (false);
    return (_Equal_unchecked(_First1, _Last1, _First2, _Pred));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Equal_unchecked1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr &  _Pred, false_type    )

inline

    {   // compare [_First1, _Last1) to [_First2, ...) using _Pred, no special optimization
    for (; _First1 != _Last1; ++_First1, (void)++_First2)
        if (!_Pred(*_First1, *_First2))
            return (false);
    return (true);
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Equal_unchecked1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr &  , true_type    )

inline

    {   // compare [_First1, _Last1) to [_First2, ...) using _Pr, memcmp optimization
    const char * const _First1_ch = reinterpret_cast<const char *>(_First1);
    const char * const _First2_ch = reinterpret_cast<const char *>(_First2);
    const size_t _Count = reinterpret_cast<const char *>(_Last1) - _First1_ch;
    return (_CSTD memcmp(_First1_ch, _First2_ch, _Count) == 0);
    }

template<class _FwdIt , class _Ty >

_Fill_memset_is_safe_helper<_FwdIt, _Ty>::type _Fill_memset_is_safe ( const _FwdIt &  , const _Ty &    )

inline

    {   // type deduction for _Fill_memset_is_safe_helper
    return {};
    }

template<class _OutIt , class _Diff , class _Ty >

_OutIt _Fill_n_unchecked ( _OutIt  _Dest, _Diff  _Count, const _Ty &  _Val  )

inline

    {   // copy _Val _Count times through [_Dest, ...), choose optimization
        // note: _Fill_n_unchecked is called directly from elsewhere in the STL
    return (_Fill_n_unchecked1(_Dest, _Count, _Val, _Fill_memset_is_safe(_Dest, _Val)));
    }

template<class _OutIt , class _Diff , class _Ty >

_OutIt _Fill_n_unchecked1 ( _OutIt  _Dest, _Diff  _Count, const _Ty &  _Val, false_type    )

inline

    {   // copy _Val _Count times through [_Dest, ...), no special optimization
    for (; 0 < _Count; --_Count, (void)++_Dest)
        *_Dest = _Val;
    return (_Dest);
    }

template<class _OutIt , class _Diff , class _Ty >

_OutIt _Fill_n_unchecked1 ( _OutIt  _Dest, _Diff  _Count, const _Ty &  _Val, true_type    )

inline

    {   // copy _Val _Count times through [_Dest, ...), memset optimization
    if (0 < _Count)
        {
        _CSTD memset(_Dest, _Val, _Count);
        return (_Dest + _Count);
        }

    return (_Dest);
    }

template<class _FwdIt , class _Ty >

void _Fill_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val  )

inline

    {   // copy _Val through [_First, _Last), choose optimization
    _Fill_unchecked1(_First, _Last, _Val, _Fill_memset_is_safe(_First, _Val));
    }

template<class _FwdIt , class _Ty >

void _Fill_unchecked1 ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, false_type    )

inline

    {   // copy _Val through [_First, _Last), no special optimization
    for (; _First != _Last; ++_First)
        *_First = _Val;
    }

template<class _FwdIt , class _Ty >

void _Fill_unchecked1 ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, true_type    )

inline

    {   // copy _Val through [_First, _Last), memset optimization
    _CSTD memset(_First, _Val, _Last - _First);
    }

template<class _InIt , class _Ty , class _Pr >

_InIt _Find_pr ( _InIt  _First, _InIt  _Last, const _Ty &  _Val, _Pr &  _Pred  )

inline

    {   // find first matching _Val, using _Pred
    for (; _First != _Last; ++_First)
        if (_Pred(*_First, _Val))
            break;
    return (_First);
    }

template<class _InIt , class _Ty >

_InIt _Find_unchecked ( _InIt  _First, _InIt  _Last, const _Ty &  _Val  )

inline

    {   // find first matching _Val; choose optimization
    // activate optimization for pointers to (const) bytes and integral values
    typedef integral_constant<bool,
        (is_same<_InIt, char *>::value
        || is_same<_InIt, signed char *>::value
        || is_same<_InIt, unsigned char *>::value
        || is_same<_InIt, const char *>::value
        || is_same<_InIt, const signed char *>::value
        || is_same<_InIt, const unsigned char *>::value)
        && is_integral<_Ty>::value
    > _Memchr_opt;
    return (_Find_unchecked1(_First, _Last, _Val, _Memchr_opt()));
    }

template<class _InIt , class _Ty >

_InIt _Find_unchecked1 ( _InIt  _First, _InIt  _Last, const _Ty &  _Val, true_type    )

inline

    {   // find first byte matching integral _Val
    if (!_Within_limits(_First, _Val))
        return (_Last);
    _First = static_cast<_InIt>(_CSTD memchr(
        _First, static_cast<unsigned char>(_Val), _Last - _First));
    return (_First ? _First : _Last);
    }

template<class _InIt , class _Ty >

_InIt _Find_unchecked1 ( _InIt  _First, _InIt  _Last, const _Ty &  _Val, false_type    )

inline

    {   // find first matching _Val
    for (; _First != _Last; ++_First)
        if (*_First == _Val)
            break;
    return (_First);
    }

template<class _Iter >

_Distance_unknown _Idl_distance ( const _Iter &  , const _Iter &    )

inline

    {   // always give up under IDL0 because _Unchecked_n blindly unwraps there
    return {};
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

bool _Is_permutation_no_deprecate ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _Pr &  _Pred  )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred, no deprecation warnings
    _DEBUG_RANGE(_First1, _Last1);
    const auto _UFirst1 = _Unchecked(_First1);
    const auto _ULast1 = _Unchecked(_Last1);
    const auto _UFirst2 = _Unchecked_n(_First2, _Idl_distance(_UFirst1, _ULast1));
    return (_Is_permutation_unchecked(_UFirst1, _ULast1, _UFirst2, _Pred));
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

bool _Is_permutation_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _Pr &  _Pred  )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred
    for (; _First1 != _Last1; ++_First1, (void)++_First2)
        if (!_Pred(*_First1, *_First2))
            {   // found first inequality, check match counts in suffix
            _FwdIt2 _Last2 = _STD next(_First2,
                _STD distance(_First1, _Last1));
            return (_Check_match_counts(_First1, _Last1,
                _First2, _Last2, _Pred));
            }

    return (true);
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

bool _Is_permutation_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr &  _Pred, forward_iterator_tag  , forward_iterator_tag    )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, _Last2),
        // using _Pred, arbitrary iterators
    for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void)++_First2)
        if (!_Pred(*_First1, *_First2))
            {   // found first inequality, check match counts in suffix
            if (_STD distance(_First1, _Last1)
                != _STD distance(_First2, _Last2))
                return (false); // lengths differ, fail
            else
                return (_Check_match_counts(_First1, _Last1,
                    _First2, _Last2, _Pred));
            }

    return (_First1 == _Last1 && _First2 == _Last2);
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

bool _Is_permutation_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr &  _Pred, random_access_iterator_tag  , random_access_iterator_tag    )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, _Last2),
        // using _Pred, random-access iterators
    if (_Last1 - _First1 != _Last2 - _First2)
        return (false);
    return (_Is_permutation_unchecked(_First1, _Last1, _First2, _Pred));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

_Lex_compare_optimize<void> _Lex_compare_memcmp_classify ( const _InIt1 &  , const _InIt2 &  , const _Pr &    )

inline

    {   // return lex_compare optimization category for arbitrary iterators
        // note that overload selecting greater<_FTy> is in <xfunctional>
    return {};
    }

template<class _Obj1 , class _Obj2 , class _FTy >

_Lex_compare_check_element_types<less<int>, _Obj1, _Obj2, _FTy> _Lex_compare_memcmp_classify ( _Obj1 *const &  , _Obj2 *const &  , const less< _FTy > &    )

inline

    {   // return lex_compare optimization category for pointer iterators and less<_FTy>
    return {};
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Lex_compare_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr &  _Pred  )

inline

    {   // order [_First1, _Last1) vs. [_First2, _Last2) using _Pred, choose optimization
    return (_Lex_compare_unchecked1(_First1, _Last1, _First2, _Last2, _Pred,
        _Lex_compare_memcmp_classify(_First1, _First2, _Pred)));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Lex_compare_unchecked1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr &  _Pred, _Lex_compare_optimize< void >    )

inline

    {   // order [_First1, _Last1) vs. [_First2, _Last2) using _Pred, no special optimization
    for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void)++_First2)
        {   // something to compare, do it
        if (_DEBUG_LT_PRED(_Pred, *_First1, *_First2))
            return (true);
        else if (_Pred(*_First2, *_First1))
            return (false);
        }

    return (_First1 == _Last1 && _First2 != _Last2);
    }

template<class _InIt1 , class _InIt2 , class _Pr , class _Memcmp_pr >

bool _Lex_compare_unchecked1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr &  , _Lex_compare_optimize< _Memcmp_pr >    )

inline

    {   // order [_First1, _Last1) vs. [_First2, _Last2) using _Pr, memcmp optimization
    const size_t _Num1 = _Last1 - _First1;
    const size_t _Num2 = _Last2 - _First2;
    const int _Ans = _CSTD memcmp(_First1, _First2, _Num1 < _Num2 ? _Num1 : _Num2);
    return (_Memcmp_pr{}(_Ans, 0) || _Ans == 0 && _Num1 < _Num2);
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 _Move_backward_unchecked ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest  )

inline

    {   // move [_First, _Last) backwards to [..., _Dest), choose optimization
        // note: _Move_backward_unchecked is called directly from elsewhere in the STL
    return (_Move_backward_unchecked1(_First, _Last,
        _Dest, _Ptr_move_cat(_First, _Dest)));
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 _Move_backward_unchecked1 ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest, _General_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) backwards to [..., _Dest), no special optimization
    while (_First != _Last)
        *--_Dest = _STD move(*--_Last);
    return (_Dest);
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 _Move_backward_unchecked1 ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest, _Trivially_copyable_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) backwards to [..., _Dest), memmove optimization
    return (_Copy_backward_memmove(_First, _Last, _Dest));
    }

template<class _InIt , class _OutIt >

_OutIt _Move_no_deprecate ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // move [_First, _Last) to [_Dest, ...), no _SCL_INSECURE_DEPRECATE_FN warnings
        // note: _Move_no_deprecate is called directly from elsewhere in the STL
    _DEBUG_RANGE(_First, _Last);
    const auto _UFirst = _Unchecked(_First);
    const auto _ULast = _Unchecked(_Last);
    const auto _UDest = _Unchecked_n(_Dest, _Idl_distance(_UFirst, _ULast));
    return (_Rechecked(_Dest,
        _Move_unchecked(_UFirst, _ULast, _UDest)));
    }

template<class _InIt , class _OutIt >

_OutIt _Move_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // move [_First, _Last) to [_Dest, ...), choose optimization
        // note: _Move_unchecked is called directly from elsewhere in the STL
    return (_Move_unchecked1(_First, _Last,
        _Dest, _Ptr_move_cat(_First, _Dest)));
    }

template<class _InIt , class _OutIt >

_OutIt _Move_unchecked1 ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _General_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) to [_Dest, ...), no special optimization
    for (; _First != _Last; ++_Dest, (void)++_First)
        *_Dest = _STD move(*_First);
    return (_Dest);
    }

template<class _InIt , class _OutIt >

_OutIt _Move_unchecked1 ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Trivially_copyable_ptr_iterator_tag    )

inline

    {   // move [_First, _Last) to [_Dest, ...), memmove optimization
    return (_Copy_memmove(_First, _Last, _Dest));
    }

template<class _Iterator >

constexpr _Iterator _Operator_arrow	(	_Iterator	_Target,
		true_type
	)

    {   // return operator-> where _Iterator is a pointer
    return (_Target);
    }

template<class _Iterator >

decltype(auto) constexpr _Operator_arrow	(	_Iterator &&	_Target,
		false_type
	)

    {   // return operator-> where _Iterator is a class type
    return (_STD forward<_Iterator>(_Target).operator->());
    }

template<class _Source , class _Dest >

_General_ptr_iterator_tag _Ptr_copy_cat ( const _Source &  , const _Dest &    )

inline

    {   // return pointer copy optimization category for arbitrary iterators
    return {};
    }

template<class _Source , class _Dest >

conditional_t<is_trivially_assignable<_Dest&, _Source&>::value, typename _Ptr_cat_helper<remove_const_t<_Source>, _Dest>::type, _General_ptr_iterator_tag> _Ptr_copy_cat ( _Source *const &  , _Dest *const &    )

inline

    {   // return pointer copy optimization category for pointers
    return {};
    }

template<class _Source , class _Dest >

_General_ptr_iterator_tag _Ptr_move_cat ( const _Source &  , const _Dest &    )

inline

    {   // return pointer move optimization category for arbitrary iterators
    return {};
    }

template<class _Source , class _Dest >

conditional_t<is_trivially_assignable<_Dest&, _Source>::value, typename _Ptr_cat_helper<remove_const_t<_Source>, _Dest>::type, _General_ptr_iterator_tag> _Ptr_move_cat ( _Source *const &  , _Dest *const &    )

inline

    {   // return pointer move optimization category for pointers
    return {};
    }

template<class _Iter , class _UIter >

_CONSTEXPR14 _Iter& _Rechecked	(	_Iter &	_Dest,
		_UIter	_Src
	)

    {   // reset checked from unchecked, generic
    _Dest = _Src;
    return (_Dest);
    }

template<class _Ty , size_t _Size>

_Array_const_iterator<_Ty, _Size>& _Rechecked ( _Array_const_iterator< _Ty, _Size > &  _Iter, typename _Array_const_iterator< _Ty, _Size >::_Unchecked_type  _Right  )

inline

    {   // convert to checked
    return (_Iter._Rechecked(_Right));
    }

template<class _Ty , size_t _Size>

_Array_iterator<_Ty, _Size>& _Rechecked ( _Array_iterator< _Ty, _Size > &  _Iter, typename _Array_iterator< _Ty, _Size >::_Unchecked_type  _Right  )

inline

    {   // convert to checked
    return (_Iter._Rechecked(_Right));
    }

template<class _BidIt >

void _Reverse_unchecked ( _BidIt  _First, _BidIt  _Last  )

inline

    {   // reverse elements in [_First, _Last), bidirectional iterators
    for (; _First != _Last && _First != --_Last; ++_First)
        _STD iter_swap(_First, _Last);
    }

template<class _BidIt >

pair<_BidIt, _BidIt> _Reverse_until_sentinel_unchecked ( _BidIt  _First, _BidIt  _Sentinel, _BidIt  _Last  )

inline

    {   // reverse until either _First or _Last hits _Sentinel
    while (_First != _Sentinel && _Last != _Sentinel)
        _STD iter_swap(_First++, --_Last);
    return (_STD make_pair(_First, _Last));
    }

template<class _FwdIt >

_FwdIt _Rotate_unchecked ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last  )

inline

    {   // rotate [_First, _Last)
    if (_First == _Mid)
        return (_Last);
    if (_Mid == _Last)
        return (_First);
    return (_Rotate_unchecked1(_First, _Mid, _Last, _Iter_cat_t<_FwdIt>()));
    }

template<class _FwdIt >

_FwdIt _Rotate_unchecked1 ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last, forward_iterator_tag    )

inline

    {   // rotate [_First, _Last), forward iterators
    for (_FwdIt _Next = _Mid, _Res = _Last; ; )
        {   // swap [_First, ...) into place
        _STD iter_swap(_First, _Next);
        if (++_First == _Mid)
            {   // quit if done, else define next interval
            if (++_Next == _Last)
                return (_Res == _Last ? _Mid : _Res);
            else
                _Mid = _Next;   // mark end of next interval
            }
        else if (++_Next == _Last)
            {   // wrap to last end
            if (_Res == _Last)
                _Res = _First;
            _Next = _Mid;
            }
        }
    }

template<class _BidIt >

_BidIt _Rotate_unchecked1 ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last, bidirectional_iterator_tag    )

inline

    {   // rotate [_First, _Last), bidirectional iterators
    _Reverse_unchecked(_First, _Mid);
    _Reverse_unchecked(_Mid, _Last);
    pair<_BidIt, _BidIt> _Tmp = _Reverse_until_sentinel_unchecked(_First, _Mid, _Last);
    _Reverse_unchecked(_Tmp.first, _Tmp.second);
    return (_Mid != _Tmp.first ? _Tmp.first : _Tmp.second);
    }

template<class _RanIt >

_RanIt _Rotate_unchecked1 ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, random_access_iterator_tag    )

inline

    {   // rotate [_First, _Last), random-access iterators
    _Reverse_unchecked(_First, _Mid);
    _Reverse_unchecked(_Mid, _Last);
    _Reverse_unchecked(_First, _Last);
    return (_First + (_Last - _Mid));
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

void _Trim_matching_suffixes ( _FwdIt1 &  , _FwdIt2 &  , _Pr &  , forward_iterator_tag  , forward_iterator_tag    )

inline

    {   // trim matching suffixes, forward iterators (do nothing)
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

void _Trim_matching_suffixes ( _FwdIt1 &  _Last1, _FwdIt2 &  _Last2, _Pr &  _Pred, bidirectional_iterator_tag  , bidirectional_iterator_tag    )

inline

    {   // trim matching suffixes, bidirectional iterators
    // assumptions: same lengths, non-empty, !_Pred(*_First1, *_First2)
    while (_Pred(*--_Last1, *--_Last2))
        ;   // find last inequality
    ++_Last1;
    ++_Last2;
    }

template<class _Iter >

constexpr _Iter _Unchecked

(

_Iter

_Src

)

    {   // construct unchecked from checked, generic
    return (_Src);
    }

template<class _Ty , size_t _Size>

_Array_const_iterator<_Ty, _Size>::_Unchecked_type _Unchecked ( _Array_const_iterator< _Ty, _Size >  _Iter )

inline

    {   // convert to unchecked
    return (_Iter._Unchecked());
    }

template<class _Ty , size_t _Size>

_Array_iterator<_Ty, _Size>::_Unchecked_type _Unchecked ( _Array_iterator< _Ty, _Size >  _Iter )

inline

    {   // convert to unchecked
    return (_Iter._Unchecked());
    }

template<class _Iter , class _Diff >

auto _Unchecked_n ( _Iter  _Src, _Diff    )

inline

    {   // blindly unwrap _Src under IDL == 0
    return (_Unchecked(_Src));
    }

template<class _Iter , class _Diff >

auto _Unchecked_n_backward ( _Iter  _Src, _Diff    )

inline

    {   // blindly unwrap _Src under IDL == 0
    return (_Unchecked(_Src));
    }

template<class _Ty >

bool _Within_limits ( const _Ty &  _Val, true_type  , true_type  , _Any_tag    )

inline

    {   // signed _Elem, signed _Ty
    return (SCHAR_MIN <= _Val && _Val <= SCHAR_MAX);
    }

template<class _Ty >

bool _Within_limits ( const _Ty &  _Val, true_type  , false_type  , true_type    )

inline

    {   // signed _Elem, unsigned _Ty, -1 == static_cast<_Ty>(-1)
    return (_Val <= SCHAR_MAX || static_cast<_Ty>(SCHAR_MIN) <= _Val);
    }

template<class _Ty >

bool _Within_limits ( const _Ty &  _Val, true_type  , false_type  , false_type    )

inline

    {   // signed _Elem, unsigned _Ty, -1 != static_cast<_Ty>(-1)
    return (_Val <= SCHAR_MAX);
    }

template<class _Ty >

bool _Within_limits ( const _Ty &  _Val, false_type  , true_type  , _Any_tag    )

inline

    {   // unsigned _Elem, signed _Ty
    return (0 <= _Val && _Val <= UCHAR_MAX);
    }

template<class _Ty >

bool _Within_limits ( const _Ty &  _Val, false_type  , false_type  , _Any_tag    )

inline

    {   // unsigned _Elem, unsigned _Ty
    return (_Val <= UCHAR_MAX);
    }

template<class _InIt , class _Ty >

bool _Within_limits ( _InIt  , const _Ty &  _Val  )

inline

    {   // check whether _Val is within the limits of _Elem
    typedef typename remove_pointer<_InIt>::type _Elem;
    return (_Within_limits(_Val, is_signed<_Elem>(), is_signed<_Ty>(),
        integral_constant<bool, -1 == static_cast<_Ty>(-1)>()));
    }

template<class _InIt >

bool _Within_limits ( _InIt  , const bool &    )

inline

    {   // bools are always within the limits of _Elem
    return (true);
    }

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_alloc

(

)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xinvalid_argument

(

_In_z_ const char *

)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xlength_error

(

_In_z_ const char *

)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xout_of_range

(

_In_z_ const char *

)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xoverflow_error

(

_In_z_ const char *

)

_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xruntime_error

(

_In_z_ const char *

)

template<class _InIt , class _Diff >

void advance ( _InIt &  _Where, _Diff  _Off  )

inline

    {   // increment iterator by offset, arbitrary iterators
        // we remove_const_t before _Iter_cat_t for better diagnostics if the user passes an iterator that is const
    _Advance1(_Where, _Off, _Iter_cat_t<remove_const_t<_InIt>>());
    }

template<class _Container >

back_insert_iterator<_Container> back_inserter ( _Container &  _Cont )

inline

    {   // return a back_insert_iterator
    return (back_insert_iterator<_Container>(_Cont));
    }

template<class _Container >

auto begin ( _Container &  _Cont ) -> decltype(_Cont.begin())

inline

    {   // get beginning of sequence
    return (_Cont.begin());
    }

template<class _Container >

auto begin ( const _Container &  _Cont ) -> decltype(_Cont.begin())

inline

    {   // get beginning of sequence
    return (_Cont.begin());
    }

template<class _Ty , size_t _Size>

constexpr _Ty* begin ( _Ty(&)  _Array[_Size] )

inline

    {   // get beginning of array
    return (_Array);
    }

template<class _Container >

constexpr auto cbegin ( const _Container &  _Cont ) -> decltype(_STD begin(_Cont))

inline

    {   // get beginning of sequence
    return (_STD begin(_Cont));
    }

template<class _Container >

constexpr auto cend ( const _Container &  _Cont ) -> decltype(_STD end(_Cont))

inline

    {   // get end of sequence
    return (_STD end(_Cont));
    }

template<class _InIt , class _OutIt >

_OutIt copy ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // copy [_First, _Last) to [_Dest, ...)
    _DEPRECATE_UNCHECKED(copy, _Dest);
    return (_Copy_no_deprecate(_First, _Last, _Dest));
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 copy_backward ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest  )

inline

    {   // copy [_First, _Last) backwards to [..., _Dest)
    _DEPRECATE_UNCHECKED(copy_backward, _Dest);
    _DEBUG_RANGE(_First, _Last);
    const auto _UFirst = _Unchecked(_First);
    const auto _ULast = _Unchecked(_Last);
    const auto _UDest = _Unchecked_n_backward(_Dest, _Idl_distance(_UFirst, _ULast));
    return (_Rechecked(_Dest,
        _Copy_backward_unchecked(_UFirst, _ULast, _UDest, _Ptr_copy_cat(_UFirst, _UDest))));
    }

template<class _InIt , class _Diff , class _OutIt >

_OutIt copy_n ( _InIt  _First, _Diff  _Count, _OutIt  _Dest  )

inline

    {   // copy [_First, _First + _Count) to [_Dest, ...)
        // Note that we _DEPRECATE_UNCHECKED _Dest because _Count logically goes with _First
    _DEPRECATE_UNCHECKED(copy_n, _Dest);
    return (_Rechecked(_Dest,
        _Copy_n_unchecked(_Unchecked_n(_First, _Count), _Count, _Unchecked_n(_Dest, _Count))));
    }

template<class _InIt , class _Ty >

_Iter_diff_t<_InIt> count ( _InIt  _First, _InIt  _Last, const _Ty &  _Val  )

inline

    {   // count elements that match _Val
    _DEBUG_RANGE(_First, _Last);
    return (_Count_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val));
    }

template<class _Container >

auto crbegin ( const _Container &  _Cont ) -> decltype(_STD rbegin(_Cont))

inline

    {   // get beginning of reversed sequence
    return (_STD rbegin(_Cont));
    }

template<class _Container >

auto crend ( const _Container &  _Cont ) -> decltype(_STD rend(_Cont))

inline

    {   // get end of reversed sequence
    return (_STD rend(_Cont));
    }

template<class _Container >

constexpr auto data ( _Container &  _Cont ) -> decltype(_Cont.data())

inline

    {   // get data() for container
    return (_Cont.data());
    }

template<class _Container >

constexpr auto data ( const _Container &  _Cont ) -> decltype(_Cont.data())

inline

    {   // get pointer to data of const container
    return (_Cont.data());
    }

template<class _Ty , size_t _Size>

constexpr _Ty* data ( _Ty(&)  _Array[_Size] )

inline

    {   // get pointer to data of array
    return (_Array);
    }

template<class _Elem >

constexpr const _Elem* data ( initializer_list< _Elem >  _Ilist )

inline

    {   // get pointer to data of initializer_list
    return (_Ilist.begin());
    }

template<class _InIt >

_Iter_diff_t<_InIt> distance ( _InIt  _First, _InIt  _Last  )

inline

    {   // return distance between iterators
    return (_Distance1(_First, _Last, _Iter_cat_t<_InIt>()));
    }

template<class _Container >

constexpr auto empty ( const _Container &  _Cont ) -> decltype(_Cont.empty())

inline

    {   // get empty() for container
    return (_Cont.empty());
    }

template<class _Ty , size_t _Size>

constexpr bool empty ( const   _Ty(&)[_Size] )

inline

    {   // get dimension==0 for array (can't happen)
    return (false);
    }

template<class _Elem >

constexpr bool empty ( initializer_list< _Elem >  _Ilist )

inline

    {   // get dimension==0 for initializer_list
    return (_Ilist.size() == 0);
    }

template<class _Container >

auto end ( _Container &  _Cont ) -> decltype(_Cont.end())

inline

    {   // get end of sequence
    return (_Cont.end());
    }

template<class _Container >

auto end ( const _Container &  _Cont ) -> decltype(_Cont.end())

inline

    {   // get end of sequence
    return (_Cont.end());
    }

template<class _Ty , size_t _Size>

constexpr _Ty* end ( _Ty(&)  _Array[_Size] )

inline

    {   // get end of array
    return (_Array + _Size);
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool equal ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr  _Pred  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...) using _Pred
    _DEPRECATE_UNCHECKED(equal, _First2);
    return (_Equal_no_deprecate(_First1, _Last1, _First2, _Pred));
    }

template<class _InIt1 , class _InIt2 >

bool equal ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2  )

inline

    {   // compare [_First1, _Last1) to [_First2, ...)
    return (_STD equal(_First1, _Last1, _First2,
        equal_to<>()));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool equal ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr  _Pred  )

inline

    {   // compare [_First1, _Last1) to [_First2, _Last2) using _Pred
    _DEBUG_RANGE(_First1, _Last1);
    _DEBUG_RANGE(_First2, _Last2);
    return (_Equal_unchecked(_Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Pred,
            _Iter_cat_t<_InIt1>(), _Iter_cat_t<_InIt2>()));
    }

template<class _InIt1 , class _InIt2 >

bool equal ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2  )

inline

    {   // compare [_First1, _Last1) to [_First2, _Last2)
    return (_STD equal(_First1, _Last1, _First2, _Last2,
        equal_to<>()));
    }

template<class _FwdIt , class _Ty >

void fill ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val  )

inline

    {   // copy _Val through [_First, _Last)
    _DEBUG_RANGE(_First, _Last);
    _Fill_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val);
    }

template<class _OutIt , class _Diff , class _Ty >

_OutIt fill_n ( _OutIt  _Dest, _Diff  _Count, const _Ty &  _Val  )

inline

    {   // copy _Val _Count times through [_Dest, ...)
    return (_Rechecked(_Dest,
        _Fill_n_unchecked(_Unchecked_n(_Dest, _Count), _Count, _Val)));
    }

template<class _InIt , class _Ty >

_InIt find ( _InIt  _First, _InIt  _Last, const _Ty &  _Val  )

inline

    {   // find first matching _Val
    _DEBUG_RANGE(_First, _Last);
    return (_Rechecked(_First,
        _Find_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val)));
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

bool is_permutation ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _Pr  _Pred  )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred
    _DEPRECATE_UNCHECKED(is_permutation, _First2);
    return (_Is_permutation_no_deprecate(_First1, _Last1, _First2, _Pred));
    }

template<class _FwdIt1 , class _FwdIt2 >

bool is_permutation ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2  )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, ...)
    return (_STD is_permutation(_First1, _Last1,
        _First2, equal_to<>()));
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

bool is_permutation ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr  _Pred  )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, _Last2),
        // using _Pred
    _DEBUG_RANGE(_First1, _Last1);
    _DEBUG_RANGE(_First2, _Last2);
    return (_Is_permutation_unchecked(_Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Pred,
        _Iter_cat_t<_FwdIt1>(), _Iter_cat_t<_FwdIt2>()));
    }

template<class _FwdIt1 , class _FwdIt2 >

bool is_permutation ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2  )

inline

    {   // test if [_First1, _Last1) == permuted [_First2, _Last2)
    return (_STD is_permutation(_First1, _Last1,
        _First2, _Last2, equal_to<>()));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool lexicographical_compare ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr  _Pred  )

inline

    {   // order [_First1, _Last1) vs. [_First2, _Last2) using _Pred
    _DEBUG_RANGE(_First1, _Last1);
    _DEBUG_RANGE(_First2, _Last2);
    return (_Lex_compare_unchecked(_Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Pred));
    }

template<class _InIt1 , class _InIt2 >

bool lexicographical_compare ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2  )

inline

    {   // order [_First1, _Last1) vs. [_First2, _Last2)
    return (_STD lexicographical_compare(_First1, _Last1,
        _First2, _Last2, less<>()));
    }

template<class _RanIt >

move_iterator<_RanIt> make_move_iterator ( _RanIt  _Iter )

inline

    {   // make move_iterator from iterator
    return (move_iterator<_RanIt>(_Iter));
    }

template<class _RanIt >

_CONSTEXPR17_11 reverse_iterator<_RanIt> make_reverse_iterator

(

_RanIt

_Iter

)

    {   // make reverse_iterator from iterator
    return (reverse_iterator<_RanIt>(_Iter));
    }

template<class _InIt , class _OutIt >

_OutIt move ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // move [_First, _Last) to [_Dest, ...)
    _DEPRECATE_UNCHECKED(move, _Dest);
    return (_Move_no_deprecate(_First, _Last, _Dest));
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 move_backward ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest  )

inline

    {   // move [_First, _Last) backwards to [..., _Dest)
    _DEPRECATE_UNCHECKED(move_backward, _Dest);
    _DEBUG_RANGE(_First, _Last);
    const auto _UFirst = _Unchecked(_First);
    const auto _ULast = _Unchecked(_Last);
    const auto _UDest = _Unchecked_n_backward(_Dest, _Idl_distance(_UFirst, _ULast));
    return (_Rechecked(_Dest,
        _Move_backward_unchecked(_UFirst, _ULast, _UDest)));
    }

template<class _InIt >

_InIt next ( _InIt  _First, _Iter_diff_t< _InIt >  _Off = 1  )

inline

    {   // increment iterator
    static_assert(is_base_of<input_iterator_tag, _Iter_cat_t<_InIt>>::value,
        "next requires input iterator");

    _STD advance(_First, _Off);
    return (_First);
    }

template<class _RanIt1 , class _RanIt2 >

_CONSTEXPR17_11 bool operator!=	(	const reverse_iterator< _RanIt1 > &	_Left,
		const reverse_iterator< _RanIt2 > &	_Right
	)

    {   // test for reverse_iterator inequality
    return (!(_Left == _Right));
    }

template<class _RanIt1 , class _RanIt2 >

bool operator!= ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

    {   // test for move_iterator inequality
    return (!(_Left == _Right));
    }

template<class _RanIt >

_CONSTEXPR17_11 reverse_iterator<_RanIt> operator+	(	typename reverse_iterator< _RanIt >::difference_type	_Off,
		const reverse_iterator< _RanIt > &	_Right
	)

    {   // return reverse_iterator + integer
    return (_Right + _Off);
    }

template<class _Ty , size_t _Size>

_Array_const_iterator<_Ty, _Size> operator+ ( typename _Array_const_iterator< _Ty, _Size >::difference_type  _Off, _Array_const_iterator< _Ty, _Size >  _Next  )

inline

    {   // add offset to iterator
    return (_Next += _Off);
    }

template<class _Ty , size_t _Size>

_Array_iterator<_Ty, _Size> operator+ ( typename _Array_iterator< _Ty, _Size >::difference_type  _Off, _Array_iterator< _Ty, _Size >  _Next  )

inline

    {   // add offset to iterator
    return (_Next += _Off);
    }

template<class _RanIt , class _Diff >

move_iterator<_RanIt> operator+ ( _Diff  _Off, const move_iterator< _RanIt > &  _Right  )

inline

    {   // return move_iterator + integer
    return (_Right + _Off);
    }

template<class _RanIt1 , class _RanIt2 >

_CONSTEXPR17_11 auto operator-	(	const reverse_iterator< _RanIt1 > &	_Left,
		const reverse_iterator< _RanIt2 > &	_Right
	)		-> decltype(_Right.base() - _Left.base())

    {   // return difference of reverse_iterators
    return (_Right.base() - _Left.base());
    }

template<class _RanIt1 , class _RanIt2 >

auto operator- ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  ) -> decltype(_Left.base() - _Right.base())

inline

    {   // test for move_iterator equality
    return (_Left.base() - _Right.base());
    }

template<class _RanIt1 , class _RanIt2 >

_CONSTEXPR17_11 bool operator<	(	const reverse_iterator< _RanIt1 > &	_Left,
		const reverse_iterator< _RanIt2 > &	_Right
	)

    {   // test for reverse_iterator < reverse_iterator
    return (_Right.base() < _Left.base());
    }

template<class _RanIt1 , class _RanIt2 >

bool operator< ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

    {   // test for move_iterator < move_iterator
    return (_Left._Less(_Right));
    }

template<class _RanIt1 , class _RanIt2 >

_CONSTEXPR17_11 bool operator<=	(	const reverse_iterator< _RanIt1 > &	_Left,
		const reverse_iterator< _RanIt2 > &	_Right
	)

    {   // test for reverse_iterator <= reverse_iterator
    return (!(_Right < _Left));
    }

template<class _RanIt1 , class _RanIt2 >

bool operator<= ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

    {   // test for move_iterator <= move_iterator
    return (!(_Right < _Left));
    }

template<class _RanIt1 , class _RanIt2 >

_CONSTEXPR17_11 bool operator==	(	const reverse_iterator< _RanIt1 > &	_Left,
		const reverse_iterator< _RanIt2 > &	_Right
	)

    {   // test for reverse_iterator equality
    return (_Left.base() == _Right.base());
    }

template<class _RanIt1 , class _RanIt2 >

bool operator== ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

    {   // test for move_iterator equality
    return (_Left._Equal(_Right));
    }

template<class _RanIt1 , class _RanIt2 >

_CONSTEXPR17_11 bool operator>	(	const reverse_iterator< _RanIt1 > &	_Left,
		const reverse_iterator< _RanIt2 > &	_Right
	)

    {   // test for reverse_iterator > reverse_iterator
    return (_Right < _Left);
    }

template<class _RanIt1 , class _RanIt2 >

bool operator> ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

    {   // test for move_iterator > move_iterator
    return (_Right < _Left);
    }

template<class _RanIt1 , class _RanIt2 >

_CONSTEXPR17_11 bool operator>=	(	const reverse_iterator< _RanIt1 > &	_Left,
		const reverse_iterator< _RanIt2 > &	_Right
	)

    {   // test for reverse_iterator >= reverse_iterator
    return (!(_Left < _Right));
    }

template<class _RanIt1 , class _RanIt2 >

bool operator>= ( const move_iterator< _RanIt1 > &  _Left, const move_iterator< _RanIt2 > &  _Right  )

inline

    {   // test for move_iterator >= move_iterator
    return (!(_Left < _Right));
    }

template<class _BidIt >

_BidIt prev ( _BidIt  _First, _Iter_diff_t< _BidIt >  _Off = 1  )

inline

    {   // decrement iterator
    static_assert(is_base_of<bidirectional_iterator_tag, _Iter_cat_t<_BidIt>>::value,
        "prev requires bidirectional iterator");

    _STD advance(_First, -_Off);
    return (_First);
    }

template<class _Container >

auto rbegin ( _Container &  _Cont ) -> decltype(_Cont.rbegin())

inline

    {   // get beginning of reversed sequence
    return (_Cont.rbegin());
    }

template<class _Container >

auto rbegin ( const _Container &  _Cont ) -> decltype(_Cont.rbegin())

inline

    {   // get beginning of reversed sequence
    return (_Cont.rbegin());
    }

template<class _Ty , size_t _Size>

reverse_iterator<_Ty *> rbegin ( _Ty(&)  _Array[_Size] )

inline

    {   // get beginning of reversed array
    return (reverse_iterator<_Ty *>(_Array + _Size));
    }

template<class _Elem >

reverse_iterator<const _Elem *> rbegin ( initializer_list< _Elem >  _Ilist )

inline

    {   // get beginning of reversed sequence
    return (reverse_iterator<const _Elem *>(_Ilist.end()));
    }

template<class _Container >

auto rend ( _Container &  _Cont ) -> decltype(_Cont.rend())

inline

    {   // get end of reversed sequence
    return (_Cont.rend());
    }

template<class _Container >

auto rend ( const _Container &  _Cont ) -> decltype(_Cont.rend())

inline

    {   // get end of reversed sequence
    return (_Cont.rend());
    }

template<class _Ty , size_t _Size>

reverse_iterator<_Ty *> rend ( _Ty(&)  _Array[_Size] )

inline

    {   // get end of reversed array
    return (reverse_iterator<_Ty *>(_Array));
    }

template<class _Elem >

reverse_iterator<const _Elem *> rend ( initializer_list< _Elem >  _Ilist )

inline

    {   // get end of reversed sequence
    return (reverse_iterator<const _Elem *>(_Ilist.begin()));
    }

template<class _BidIt >

void reverse ( _BidIt  _First, _BidIt  _Last  )

inline

    {   // reverse elements in [_First, _Last)
    _DEBUG_RANGE(_First, _Last);
    _Reverse_unchecked(_Unchecked(_First), _Unchecked(_Last));
    }

template<class _FwdIt >

_FwdIt rotate ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last  )

inline

    {   // rotate [_First, _Last)
    _DEBUG_RANGE(_First, _Mid);
    _DEBUG_RANGE(_Mid, _Last);
    return (_Rechecked(_First,
        _Rotate_unchecked(_Unchecked(_First), _Unchecked(_Mid),
        _Unchecked(_Last))));
    }

template<class _Container >

constexpr auto size ( const _Container &  _Cont ) -> decltype(_Cont.size())

inline

    {   // get size() for container
    return (_Cont.size());
    }

template<class _Ty , size_t _Size>

constexpr size_t size ( const   _Ty(&)[_Size] )

inline

    {   // get dimension for array
    return (_Size);
    }

Variable Documentation

template<class _Iter >

_Is_checked_helper<_Iter>::type _Is_checked(_Iter)

inline

    {   // return type is true_type if iterator is checked
    return {};
    }

constexpr allocator_arg_t allocator_arg {}