algorithm File Reference

#include <xmemory>
#include <cliext/memory>

Classes
class	cliext::_ISort

Namespaces
	cliext

Macros
#define	_ALGORITHM_
#define	_DEBUG_HEAP_PRED(first, last, pred)
#define	_CLI_ALGORITHM_
#define	_STLCLRDB_HEAP(first, last)
#define	_STLCLRDB_HEAP_PRED(first, last, pred)

Functions
template<class _Iter1 , class _Iter2 , class _UIter1 , class _UIter2 >
pair< _Iter1, _Iter2 >	_Rechecked_both (_Iter1 _Dest1, _Iter2 _Dest2, pair< _UIter1, _UIter2 > _Src)
template<class _InIt , class _Fn1 >
void	_For_each_unchecked (_InIt _First, _InIt _Last, _Fn1 &_Func)
template<class _InIt , class _Fn1 >
_Fn1	for_each (_InIt _First, _InIt _Last, _Fn1 _Func)
template<class _InIt , class _Pr >
_InIt	_Find_if_unchecked (_InIt _First, _InIt _Last, _Pr &_Pred)
template<class _InIt , class _Pr >
_InIt	find_if (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	_Adjacent_find_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
_FwdIt	adjacent_find (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	adjacent_find (_FwdIt _First, _FwdIt _Last)
template<class _InIt , class _Pr >
iterator_traits< _InIt >::difference_type	_Count_if_unchecked (_InIt _First, _InIt _Last, _Pr &_Pred)
template<class _InIt , class _Pr >
iterator_traits< _InIt >::difference_type	count_if (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
pair< _InIt1, _InIt2 >	_Mismatch_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
auto	_Mismatch_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred, input_iterator_tag, input_iterator_tag) -> pair< _InIt1, decltype(_Unchecked_idl0(_First2))>
template<class _InIt1 , class _InIt2 , class _Pr >
pair< _InIt1, _UNCHECKED_TYPE(_InIt2)>	_Mismatch_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred, random_access_iterator_tag, random_access_iterator_tag)
template<class _InIt1 , class _InIt2 , class _Pr >
pair< _InIt1, _InIt2 >	_Mismatch_no_deprecate (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
pair< _InIt1, _InIt2 >	mismatch (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
template<class _InIt1 , class _InIt2 >
pair< _InIt1, _InIt2 >	mismatch (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
template<class _InIt1 , class _InIt2 , class _Pr >
pair< _InIt1, _InIt2 >	_Mismatch_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
pair< _InIt1, _InIt2 >	mismatch (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _InIt1 , class _InIt2 >
pair< _InIt1, _InIt2 >	mismatch (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
template<class _InIt , class _Pr >
bool	_All_of_unchecked (_InIt _First, _InIt _Last, _Pr &_Pred)
template<class _InIt , class _Pr >
bool	all_of (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _InIt , class _Pr >
bool	_Any_of_unchecked (_InIt _First, _InIt _Last, _Pr &_Pred)
template<class _InIt , class _Pr >
bool	any_of (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _InIt , class _Pr >
bool	_None_of_unchecked (_InIt _First, _InIt _Last, _Pr &_Pred)
template<class _InIt , class _Pr >
bool	none_of (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _InIt , class _Pr >
_InIt	_Find_if_not_unchecked (_InIt _First, _InIt _Last, _Pr &_Pred)
template<class _InIt , class _Pr >
_InIt	find_if_not (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	_Copy_if_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	_Copy_if_no_deprecate (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	copy_if (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _InIt , class _OutIt1 , class _OutIt2 , class _Pr >
pair< _OutIt1, _OutIt2 >	_Partition_copy_unchecked (_InIt _First, _InIt _Last, _OutIt1 _Dest1, _OutIt2 _Dest2, _Pr &_Pred)
template<class _InIt , class _OutIt1 , class _OutIt2 , class _Pr >
pair< _OutIt1, _OutIt2 >	_Partition_copy_no_deprecate (_InIt _First, _InIt _Last, _OutIt1 _Dest1, _OutIt2 _Dest2, _Pr &_Pred)
template<class _InIt , class _OutIt1 , class _OutIt2 , class _Pr >
pair< _OutIt1, _OutIt2 >	partition_copy (_InIt _First, _InIt _Last, _OutIt1 _Dest1, _OutIt2 _Dest2, _Pr _Pred)
template<class _InIt , class _Pr >
bool	_Is_partitioned_unchecked (_InIt _First, _InIt _Last, _Pr &_Pred)
template<class _InIt , class _Pr >
bool	is_partitioned (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	_Partition_point_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
_FwdIt	partition_point (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	_Search_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred, forward_iterator_tag, forward_iterator_tag)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	_Search_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 >
_FwdIt1	search (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	search (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt , class _Diff , class _Ty , class _Pr >
_FwdIt	_Search_n_unchecked (_FwdIt _First, _FwdIt _Last, _Diff _Count, const _Ty &_Val, _Pr &_Pred, forward_iterator_tag)
template<class _FwdIt , class _Diff , class _Ty , class _Pr >
_FwdIt	_Search_n_unchecked (_FwdIt _First, _FwdIt _Last, _Diff _Count, const _Ty &_Val, _Pr &_Pred, random_access_iterator_tag)
template<class _FwdIt , class _Diff , class _Ty , class _Pr >
_FwdIt	search_n (_FwdIt _First, _FwdIt _Last, _Diff _Count, const _Ty &_Val, _Pr _Pred)
template<class _FwdIt , class _Diff , class _Ty >
_FwdIt	search_n (_FwdIt _First, _FwdIt _Last, _Diff _Count, const _Ty &_Val)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	_Find_end_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	find_end (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	find_end (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	_Find_first_of_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr &_Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	find_first_of (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	find_first_of (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2	_Swap_ranges_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _Dest)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2	_Swap_ranges1 (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _Dest, forward_iterator_tag, forward_iterator_tag)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2	_Swap_ranges1 (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _Dest, random_access_iterator_tag, random_access_iterator_tag)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2	swap_ranges (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _Dest)
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt	_Transform_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 &_Func)
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt	_Transform_no_deprecate1 (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 &_Func, input_iterator_tag, _Any_tag)
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt	_Transform_no_deprecate1 (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 &_Func, random_access_iterator_tag, random_access_iterator_tag)
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt	_Transform_no_deprecate (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 &_Func)
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt	transform (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	_Transform_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 &_Func)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	_Transform_no_deprecate2 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 &_Func, input_iterator_tag, _Any_tag)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	_Transform_no_deprecate2 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 &_Func, random_access_iterator_tag, random_access_iterator_tag)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	_Transform_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 &_Func, input_iterator_tag, input_iterator_tag)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	_Transform_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 &_Func, random_access_iterator_tag, random_access_iterator_tag)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	_Transform_no_deprecate (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 &_Func)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	transform (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
template<class _FwdIt , class _Ty >
void	_Replace_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty &_Oldval, const _Ty &_Newval)
template<class _FwdIt , class _Ty >
void	replace (_FwdIt _First, _FwdIt _Last, const _Ty &_Oldval, const _Ty &_Newval)
template<class _FwdIt , class _Pr , class _Ty >
void	_Replace_if_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred, const _Ty &_Val)
template<class _FwdIt , class _Pr , class _Ty >
void	replace_if (_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty &_Val)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	_Replace_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty &_Oldval, const _Ty &_Newval)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	_Replace_copy1 (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty &_Oldval, const _Ty &_Newval, input_iterator_tag, _Any_tag)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	_Replace_copy1 (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty &_Oldval, const _Ty &_Newval, random_access_iterator_tag, random_access_iterator_tag)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	replace_copy (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty &_Oldval, const _Ty &_Newval)
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt	_Replace_copy_if_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred, const _Ty &_Val)
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt	_Replace_copy_if_no_deprecate1 (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred, const _Ty &_Val, input_iterator_tag, _Any_tag)
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt	_Replace_copy_if_no_deprecate1 (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred, const _Ty &_Val, random_access_iterator_tag, random_access_iterator_tag)
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt	_Replace_copy_if_no_deprecate (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred, const _Ty &_Val)
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt	replace_copy_if (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty &_Val)
template<class _FwdIt , class _Fn0 >
void	_Generate_unchecked (_FwdIt _First, _FwdIt _Last, _Fn0 &_Func)
template<class _FwdIt , class _Fn0 >
void	generate (_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
template<class _OutIt , class _Diff , class _Fn0 >
_OutIt	_Generate_n_unchecked (_OutIt _Dest, _Diff _Count, _Fn0 &_Func)
template<class _OutIt , class _Diff , class _Fn0 >
_OutIt	generate_n (_OutIt _Dest, _Diff _Count, _Fn0 _Func)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	_Remove_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty &_Val)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	remove_copy (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty &_Val)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	_Remove_copy_if_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	_Remove_copy_if_no_deprecate (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	remove_copy_if (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _FwdIt , class _Ty >
_FwdIt	_Remove_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
template<class _FwdIt , class _Ty >
_FwdIt	remove (_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
template<class _FwdIt , class _Pr >
_FwdIt	_Remove_if_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
_FwdIt	remove_if (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	_Unique_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
_FwdIt	unique (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	unique (_FwdIt _First, _FwdIt _Last)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	_Unique_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred, input_iterator_tag)
template<class _FwdIt , class _OutIt , class _Pr >
_OutIt	_Unique_copy_unchecked (_FwdIt _First, _FwdIt _Last, _OutIt _Dest, _Pr &_Pred, forward_iterator_tag)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	_Unique_copy_no_deprecate (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _InIt , class _OutIt >
_OutIt	unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _BidIt , class _OutIt >
_OutIt	_Reverse_copy_unchecked (_BidIt _First, _BidIt _Last, _OutIt _Dest)
template<class _BidIt , class _OutIt >
_OutIt	_Reverse_copy1 (_BidIt _First, _BidIt _Last, _OutIt _Dest, bidirectional_iterator_tag, _Any_tag)
template<class _BidIt , class _OutIt >
_OutIt	_Reverse_copy1 (_BidIt _First, _BidIt _Last, _OutIt _Dest, random_access_iterator_tag, random_access_iterator_tag)
template<class _BidIt , class _OutIt >
_OutIt	reverse_copy (_BidIt _First, _BidIt _Last, _OutIt _Dest)
template<class _FwdIt , class _OutIt >
_OutIt	_Rotate_copy_unchecked (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
template<class _FwdIt , class _OutIt >
_OutIt	_Rotate_copy1 (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest, forward_iterator_tag, _Any_tag)
template<class _FwdIt , class _OutIt >
_OutIt	_Rotate_copy1 (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest, random_access_iterator_tag, random_access_iterator_tag)
template<class _FwdIt , class _OutIt >
_OutIt	rotate_copy (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
template<class _RanIt , class _Fn1 >
void	_Random_shuffle_unchecked (_RanIt _First, _RanIt _Last, _Fn1 &_Func)
template<class _RanIt , class _Fn1 >
void	_Random_shuffle1 (_RanIt _First, _RanIt _Last, _Fn1 &_Func)
template<class _RanIt , class _Urng >
void	shuffle (_RanIt _First, _RanIt _Last, _Urng &&_Func)
template<class _FwdIt , class _Pr >
_FwdIt	_Partition_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred, forward_iterator_tag)
template<class _BidIt , class _Pr >
_BidIt	_Partition_unchecked (_BidIt _First, _BidIt _Last, _Pr &_Pred, bidirectional_iterator_tag)
template<class _FwdIt , class _Pr >
_FwdIt	partition (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty >
_BidIt	_Buffered_rotate_unchecked (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > &_Tempbuf)
template<class _BidIt , class _Pr , class _Diff , class _Ty >
_BidIt	_Stable_partition_unchecked1 (_BidIt _First, _BidIt _Last, _Pr &_Pred, _Diff _Count, _Temp_iterator< _Ty > &_Tempbuf)
template<class _BidIt , class _Pr >
_BidIt	_Stable_partition_unchecked (_BidIt _First, _BidIt _Last, _Pr &_Pred)
template<class _BidIt , class _Pr >
_BidIt	stable_partition (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void	_Push_heap_by_index (_RanIt _First, _Diff _Hole, _Diff _Top, _Ty &&_Val, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	_Push_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	push_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	push_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void	_Pop_heap_hole_by_index (_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty &&_Val, _Pr &_Pred)
template<class _RanIt , class _Ty , class _Pr >
void	_Pop_heap_hole_unchecked (_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty &&_Val, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	_Pop_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	pop_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	pop_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Pr >
void	_Make_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	make_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	make_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Pr >
void	_Sort_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	sort_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	sort_heap (_RanIt _First, _RanIt _Last)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	_Lower_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr &_Pred)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	lower_bound (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr _Pred)
template<class _FwdIt , class _Ty >
_FwdIt	lower_bound (_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	_Upper_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr &_Pred)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	upper_bound (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr _Pred)
template<class _FwdIt , class _Ty >
_FwdIt	upper_bound (_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
template<class _FwdIt , class _Ty , class _Pr >
pair< _FwdIt, _FwdIt >	_Equal_range_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr &_Pred)
template<class _FwdIt , class _Ty , class _Pr >
pair< _FwdIt, _FwdIt >	equal_range (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr _Pred)
template<class _FwdIt , class _Ty >
pair< _FwdIt, _FwdIt >	equal_range (_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
template<class _FwdIt , class _Ty , class _Pr >
bool	_Binary_search_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr &_Pred)
template<class _FwdIt , class _Ty , class _Pr >
bool	binary_search (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr _Pred)
template<class _FwdIt , class _Ty >
bool	binary_search (_FwdIt _First, _FwdIt _Last, const _Ty &_Val)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Merge_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Merge_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred, input_iterator_tag, input_iterator_tag, _Any_tag)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Merge_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred, random_access_iterator_tag, random_access_iterator_tag, random_access_iterator_tag)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Merge_no_deprecate (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	merge (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	merge (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _BidIt1 , class _BidIt2 , class _BidIt3 , class _Pr >
_BidIt3	_Buffered_merge_backward_unchecked (_BidIt1 _First1, _BidIt1 _Last1, _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Pr &_Pred, bool _In_place=false)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Buffered_merge_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred, bool _In_place=false)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	_Buffered_merge_unchecked (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > &_Tempbuf, _Pr &_Pred)
template<class _BidIt , class _Pr >
void	_Inplace_merge_unchecked (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr &_Pred)
template<class _BidIt , class _Pr >
void	inplace_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred)
template<class _BidIt >
void	inplace_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last)
template<class _BidIt , class _Pr >
void	_Insertion_sort_unchecked (_BidIt _First, _BidIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	_Med3_unchecked (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	_Guess_median_unchecked (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
pair< _RanIt, _RanIt >	_Partition_by_median_guess_unchecked (_RanIt _First, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Diff , class _Pr >
void	_Sort_unchecked1 (_RanIt _First, _RanIt _Last, _Diff _Ideal, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	_Sort_unchecked (_RanIt _First, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	sort (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	sort (_RanIt _First, _RanIt _Last)
template<class _BidIt , class _OutIt , class _Diff , class _Pr >
void	_Chunked_merge_unchecked (_BidIt _First, _BidIt _Last, _OutIt _Dest, _Diff _Chunk, _Diff _Count, _Pr &_Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	_Buffered_merge_sort_unchecked (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > &_Tempbuf, _Pr &_Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	_Stable_sort_unchecked1 (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > &_Tempbuf, _Pr &_Pred)
template<class _BidIt , class _Pr >
void	_Stable_sort_unchecked (_BidIt _First, _BidIt _Last, _Pr &_Pred)
template<class _BidIt , class _Pr >
void	stable_sort (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt >
void	stable_sort (_BidIt _First, _BidIt _Last)
template<class _RanIt , class _Pr >
void	_Partial_sort_unchecked (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	partial_sort (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	partial_sort (_RanIt _First, _RanIt _Mid, _RanIt _Last)
template<class _InIt , class _RanIt , class _Pr >
_RanIt	_Partial_sort_copy_unchecked (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr &_Pred)
template<class _InIt , class _RanIt , class _Pr >
_RanIt	partial_sort_copy (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred)
template<class _InIt , class _RanIt >
_RanIt	partial_sort_copy (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2)
template<class _RanIt , class _Pr >
void	_Nth_element_unchecked (_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
void	nth_element (_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	nth_element (_RanIt _First, _RanIt _Nth, _RanIt _Last)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	_Includes_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	includes (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _InIt1 , class _InIt2 >
bool	includes (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Set_union_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Set_union_no_deprecate (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	set_union (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	set_union (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Set_intersection_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Set_intersection_no_deprecate (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	set_intersection (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	set_intersection (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Set_difference_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Set_difference_no_deprecate (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	set_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	set_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Set_symmetric_difference_no_deprecate1 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	_Set_symmetric_difference_no_deprecate (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr &_Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	set_symmetric_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	set_symmetric_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _FwdIt , class _Pr >
_FwdIt	_Max_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
_FwdIt	max_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	max_element (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	_Min_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
_FwdIt	min_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	min_element (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
pair< _FwdIt, _FwdIt >	_Minmax_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
pair< _FwdIt, _FwdIt >	minmax_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
pair< _FwdIt, _FwdIt >	minmax_element (_FwdIt _First, _FwdIt _Last)
template<class _Ty , class _Pr >
constexpr const _Ty &()	max (const _Ty &_Left, const _Ty &_Right, _Pr _Pred) _NOEXCEPT_OP(_NOEXCEPT_OP(_DEBUG_LT_PRED(_Pred
template<class _Ty , class _Pr >
_Ty()	max (_XSTD initializer_list< _Ty > _Ilist, _Pr _Pred)
template<class _Ty >
	_Post_equal_to_ (_Left< _Right?_Right:_Left) const expr const _Ty &(max)(const _Ty &_Left
const _Ty &_Right	_NOEXCEPT_OP (_NOEXCEPT_OP(_DEBUG_LT(_Left, _Right)))
template<class _Ty >
_Ty()	max (_XSTD initializer_list< _Ty > _Ilist)
template<class _Ty , class _Pr >
constexpr const _Ty &()	min (const _Ty &_Left, const _Ty &_Right, _Pr _Pred) _NOEXCEPT_OP(_NOEXCEPT_OP(_DEBUG_LT_PRED(_Pred
template<class _Ty , class _Pr >
_Ty()	min (_XSTD initializer_list< _Ty > _Ilist, _Pr _Pred)
template<class _Ty >
	_Post_equal_to_ (_Right< _Left?_Right:_Left) const expr const _Ty &(min)(const _Ty &_Left
const _Ty &_Right	_NOEXCEPT_OP (_NOEXCEPT_OP(_DEBUG_LT(_Right, _Left)))
template<class _Ty >
_Ty()	min (_XSTD initializer_list< _Ty > _Ilist)
template<class _Ty , class _Pr >
constexpr pair< const _Ty &, const _Ty & >	minmax (const _Ty &_Left, const _Ty &_Right, _Pr _Pred)
template<class _Ty , class _Pr >
pair< _Ty, _Ty >	minmax (_XSTD initializer_list< _Ty > _Ilist, _Pr _Pred)
template<class _Ty >
constexpr pair< const _Ty &, const _Ty & >	minmax (const _Ty &_Left, const _Ty &_Right)
template<class _Ty >
pair< _Ty, _Ty >	minmax (_XSTD initializer_list< _Ty > _Ilist)
template<class _BidIt , class _Pr >
bool	_Next_permutation_unchecked (_BidIt _First, _BidIt _Last, _Pr &_Pred)
template<class _BidIt , class _Pr >
bool	next_permutation (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt >
bool	next_permutation (_BidIt _First, _BidIt _Last)
template<class _BidIt , class _Pr >
bool	_Prev_permutation_unchecked (_BidIt _First, _BidIt _Last, _Pr &_Pred)
template<class _BidIt , class _Pr >
bool	prev_permutation (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt >
bool	prev_permutation (_BidIt _First, _BidIt _Last)
template<class _RanIt , class _Pr >
_RanIt	_Is_heap_until_unchecked (_RanIt _First, _RanIt _Last, _Pr &_Pred)
template<class _RanIt , class _Pr >
_RanIt	is_heap_until (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
bool	is_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
_RanIt	is_heap_until (_RanIt _First, _RanIt _Last)
template<class _RanIt >
bool	is_heap (_RanIt _First, _RanIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	_Is_sorted_until_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
_FwdIt	is_sorted_until (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
bool	is_sorted (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	is_sorted_until (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt >
bool	is_sorted (_FwdIt _First, _FwdIt _Last)
template<class _InIt , class _Fn1 >
_Fn1	cliext::for_each_unchecked (_InIt _First, _InIt _Last, _Fn1 _Func)
template<class _InIt , class _Fn1 >
_Fn1	cliext::for_each (_InIt _First, _InIt _Last, _Fn1 _Func)
template<class _InIt , class _Ty >
_InIt	cliext::find_unchecked (_InIt _First, _InIt _Last, const _Ty%_Val)
template<class _InIt , class _Ty >
_InIt	cliext::find (_InIt _First, _InIt _Last, const _Ty%_Val)
const char *	cliext::find (const char *_First, const char *_Last, int _Val)
const signed char *	cliext::find (const signed char *_First, const signed char *_Last, int _Val)
const unsigned char *	cliext::find (const unsigned char *_First, const unsigned char *_Last, int _Val)
template<class _InIt , class _Pr >
_InIt	cliext::find_if_unchecked (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _InIt , class _Pr >
_InIt	cliext::find_if (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	cliext::adjacent_find_unchecked (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt >
_FwdIt	cliext::adjacent_find (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	cliext::adjacent_find_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	cliext::adjacent_find (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _InIt , class _Ty >
iterator_traits< _InIt >::difference_type	cliext::count_unchecked (_InIt _First, _InIt _Last, const _Ty%_Val)
template<class _InIt , class _Ty >
iterator_traits< _InIt >::difference_type	cliext::count (_InIt _First, _InIt _Last, const _Ty%_Val)
template<class _InIt , class _Pr >
iterator_traits< _InIt >::difference_type	cliext::count_if_unchecked (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _InIt , class _Pr >
iterator_traits< _InIt >::difference_type	cliext::count_if (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	cliext::search_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	cliext::search (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	cliext::search_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	cliext::search (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1	cliext::_Search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, forward_iterator_tag)
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1	cliext::_Search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, random_access_iterator_tag)
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1	cliext::search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val)
template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >
_FwdIt1	cliext::_Search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, _Pr _Pred, forward_iterator_tag)
template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >
_FwdIt1	cliext::_Search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, _Pr _Pred, random_access_iterator_tag)
template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >
_FwdIt1	cliext::search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	cliext::find_end_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	cliext::find_end (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	cliext::find_end_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	cliext::find_end (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	cliext::find_first_of_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	cliext::find_first_of (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	cliext::find_first_of_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	cliext::find_first_of (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
void	cliext::iter_swap (_FwdIt1 _Left, _FwdIt2 _Right)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2	cliext::swap_ranges_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2	cliext::swap_ranges (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt	cliext::transform_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt	cliext::transform (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	cliext::transform_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	cliext::transform (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
template<class _FwdIt , class _Ty >
void	cliext::replace_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Oldval, const _Ty%_Newval)
template<class _FwdIt , class _Ty >
void	cliext::replace (_FwdIt _First, _FwdIt _Last, const _Ty%_Oldval, const _Ty%_Newval)
template<class _FwdIt , class _Pr , class _Ty >
void	cliext::replace_if_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty%_Val)
template<class _FwdIt , class _Pr , class _Ty >
void	cliext::replace_if (_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty%_Val)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	cliext::replace_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Oldval, const _Ty%_Newval)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	cliext::replace_copy (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Oldval, const _Ty%_Newval)
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt	cliext::replace_copy_if_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty%_Val)
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt	cliext::replace_copy_if (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty%_Val)
template<class _FwdIt , class _Fn0 >
void	cliext::generate_unchecked (_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
template<class _FwdIt , class _Fn0 >
void	cliext::generate (_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
template<class _OutIt , class _Diff , class _Fn0 >
void	cliext::generate_n_unchecked (_OutIt _Dest, _Diff _Count, _Fn0 _Func)
template<class _OutIt , class _Diff , class _Fn0 >
void	cliext::generate_n (_OutIt _Dest, _Diff _Count, _Fn0 _Func)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	cliext::remove_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Val)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	cliext::remove_copy (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Val)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	cliext::remove_copy_if_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	cliext::remove_copy_if (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _FwdIt , class _Ty >
_FwdIt	cliext::remove_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Ty >
_FwdIt	cliext::remove (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Pr >
_FwdIt	cliext::remove_if_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	cliext::remove_if (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	cliext::unique_unchecked (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt >
_FwdIt	cliext::unique (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	cliext::unique_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	cliext::unique (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _InIt , class _OutIt >
_OutIt	cliext::_Unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, input_iterator_tag)
template<class _FwdIt , class _OutIt >
_OutIt	cliext::_Unique_copy (_FwdIt _First, _FwdIt _Last, _OutIt _Dest, forward_iterator_tag)
template<class _BidIt , class _OutIt >
_OutIt	cliext::_Unique_copy (_BidIt _First, _BidIt _Last, _OutIt _Dest, bidirectional_iterator_tag)
template<class _RanIt , class _OutIt >
_OutIt	cliext::_Unique_copy (_RanIt _First, _RanIt _Last, _OutIt _Dest, random_access_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	cliext::unique_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	cliext::unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	cliext::_Unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, input_iterator_tag)
template<class _FwdIt , class _OutIt , class _Pr >
_OutIt	cliext::_Unique_copy (_FwdIt _First, _FwdIt _Last, _OutIt _Dest, _Pr _Pred, forward_iterator_tag)
template<class _BidIt , class _OutIt , class _Pr >
_OutIt	cliext::_Unique_copy (_BidIt _First, _BidIt _Last, _OutIt _Dest, _Pr _Pred, bidirectional_iterator_tag)
template<class _RanIt , class _OutIt , class _Pr >
_OutIt	cliext::_Unique_copy (_RanIt _First, _RanIt _Last, _OutIt _Dest, _Pr _Pred, random_access_iterator_tag)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	cliext::unique_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	cliext::unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _BidIt >
void	cliext::_Reverse (_BidIt _First, _BidIt _Last, bidirectional_iterator_tag)
template<class _RanIt >
void	cliext::_Reverse (_RanIt _First, _RanIt _Last, random_access_iterator_tag)
template<class _BidIt >
void	cliext::reverse_unchecked (_BidIt _First, _BidIt _Last)
template<class _BidIt >
void	cliext::reverse (_BidIt _First, _BidIt _Last)
template<class _BidIt , class _OutIt >
_OutIt	cliext::reverse_copy_unchecked (_BidIt _First, _BidIt _Last, _OutIt _Dest)
template<class _BidIt , class _OutIt >
_OutIt	cliext::reverse_copy (_BidIt _First, _BidIt _Last, _OutIt _Dest)
template<class _FwdIt >
void	cliext::_Rotate (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, forward_iterator_tag)
template<class _BidIt >
void	cliext::_Rotate (_BidIt _First, _BidIt _Mid, _BidIt _Last, bidirectional_iterator_tag)
template<class _RanIt >
void	cliext::_Rotate (_RanIt _First, _RanIt _Mid, _RanIt _Last, random_access_iterator_tag)
template<class _FwdIt >
void	cliext::rotate_unchecked (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
template<class _FwdIt >
void	cliext::rotate (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
template<class _FwdIt , class _OutIt >
_OutIt	cliext::rotate_copy_unchecked (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
template<class _FwdIt , class _OutIt >
_OutIt	cliext::rotate_copy (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
int	cliext::_Rand (void)
template<class _RanIt >
void	cliext::random_shuffle_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	cliext::random_shuffle (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Fn1 >
void	cliext::random_shuffle_unchecked (_RanIt _First, _RanIt _Last, _Fn1%_Func)
template<class _RanIt , class _Fn1 >
void	cliext::random_shuffle (_RanIt _First, _RanIt _Last, _Fn1%_Func)
template<class _BidIt , class _Pr >
_BidIt	cliext::partition_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
_BidIt	cliext::partition (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr , class _Diff , class _Ty >
_BidIt	cliext::_XStable_partition (_BidIt _First, _BidIt _Last, _Pr _Pred, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
template<class _BidIt , class _Pr >
_BidIt	cliext::stable_partition_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
_BidIt	cliext::stable_partition (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _RanIt , class _Diff , class _Ty >
void	cliext::_XPush_heap (_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val)
template<class _RanIt >
void	cliext::push_heap_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	cliext::push_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void	cliext::_XPush_heap (_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::push_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::push_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Diff , class _Ty >
void	cliext::_XAdjust_heap (_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
template<class _RanIt , class _Ty >
void	cliext::_XPop_heap (_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty _Val)
template<class _RanIt >
void	cliext::pop_heap_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	cliext::pop_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void	cliext::_XAdjust_heap (_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val, _Pr _Pred)
template<class _RanIt , class _Ty , class _Pr >
void	cliext::_XPop_heap (_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty _Val, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::pop_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::pop_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	cliext::make_heap_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	cliext::make_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Pr >
void	cliext::make_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::make_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	cliext::sort_heap_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	cliext::sort_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Pr >
void	cliext::sort_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::sort_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _FwdIt , class _Ty >
_FwdIt	cliext::lower_bound_unchecked (_FwdIt _First, _FwdIt _Last, _Ty%_Val)
template<class _FwdIt , class _Ty >
_FwdIt	cliext::lower_bound (_FwdIt _First, _FwdIt _Last, _Ty%_Val)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	cliext::lower_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	cliext::lower_bound (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt , class _Ty >
_FwdIt	cliext::upper_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Ty >
_FwdIt	cliext::upper_bound (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	cliext::upper_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	cliext::upper_bound (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt , class _Ty >
	cliext::_PAIR_TYPE (_FwdIt) equal_range_unchecked(_FwdIt _First
	cliext::_Iter_distance (_First, _Last, _Count)
	cliext::for (;0< _Count;)
	cliext::return (_PAIR_TYPE(_FwdIt)(_First, _First))
	cliext::return (cliext::equal_range_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val))
template<class _FwdIt , class _Ty , class _Pr >
	cliext::_PAIR_TYPE (_FwdIt) equal_range_unchecked(_FwdIt _First
	cliext::return (cliext::equal_range_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val, _Pred))
template<class _FwdIt , class _Ty >
bool	cliext::binary_search_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Ty >
bool	cliext::binary_search (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Ty , class _Pr >
bool	cliext::binary_search_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt , class _Ty , class _Pr >
bool	cliext::binary_search (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	cliext::merge_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	cliext::merge (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	cliext::merge_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	cliext::merge (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty >
_BidIt	cliext::_XBuffered_rotate (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
template<class _BidIt1 , class _BidIt2 , class _BidIt3 >
_BidIt3	cliext::_XMerge_backward (_BidIt1 _First1, _BidIt1 _Last1, _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest)
template<class _BidIt , class _Diff , class _Ty >
void	cliext::_XBuffered_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
template<class _BidIt >
void	cliext::inplace_merge_unchecked (_BidIt _First, _BidIt _Mid, _BidIt _Last)
template<class _BidIt >
void	cliext::inplace_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last)
template<class _BidIt1 , class _BidIt2 , class _BidIt3 , class _Pr >
_BidIt3	cliext::_XMerge_backward (_BidIt1 _First1, _BidIt1 _Last1, _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	cliext::_XBuffered_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
template<class _BidIt , class _Pr >
void	cliext::inplace_merge_unchecked (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
void	cliext::inplace_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred)
template<class _BidIt >
void	cliext::_XInsertion_sort (_BidIt _First, _BidIt _Last)
template<class _RanIt >
void	cliext::_XMed3 (_RanIt _First, _RanIt _Mid, _RanIt _Last)
template<class _RanIt >
void	cliext::_XMedian (_RanIt _First, _RanIt _Mid, _RanIt _Last)
template<class _RanIt >
	cliext::_PAIR_TYPE (_RanIt) _XUnguarded_partition(_RanIt _First
	cliext::while (_First< _Pfirst &&!_STLCLRDB_LT(*(_Pfirst-1),*_Pfirst)&&!(*_Pfirst< *(_Pfirst-1)))--_Pfirst
	cliext::for (;;)
template<class _RanIt , class _Diff >
void	cliext::_XSort (_RanIt _First, _RanIt _Last, _Diff _Ideal)
template<class _RanIt >
void	cliext::sort_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	cliext::sort (_RanIt _First, _RanIt _Last)
template<class _BidIt , class _Pr >
void	cliext::_XInsertion_sort (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::_XMed3 (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::_XMedian (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
	cliext::_PAIR_TYPE (_RanIt) _XUnguarded_partition(_RanIt _First
template<class _RanIt , class _Diff , class _Pr >
void	cliext::_XSort (_RanIt _First, _RanIt _Last, _Diff _Ideal, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::sort_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::sort (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _BidIt , class _OutIt , class _Diff >
void	cliext::_XChunked_merge (_BidIt _First, _BidIt _Last, _OutIt _Dest, _Diff _Chunk, _Diff _Count)
template<class _BidIt , class _Diff , class _Ty >
void	cliext::_XBuffered_merge_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
template<class _BidIt , class _Diff , class _Ty >
void	cliext::_XStable_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
template<class _BidIt >
void	cliext::stable_sort_unchecked (_BidIt _First, _BidIt _Last)
template<class _BidIt >
void	cliext::stable_sort (_BidIt _First, _BidIt _Last)
template<class _BidIt , class _OutIt , class _Diff , class _Pr >
void	cliext::_XChunked_merge (_BidIt _First, _BidIt _Last, _OutIt _Dest, _Diff _Chunk, _Diff _Count, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	cliext::_XBuffered_merge_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	cliext::_XStable_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
template<class _BidIt , class _Pr >
void	cliext::stable_sort_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
void	cliext::stable_sort (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _RanIt >
void	cliext::partial_sort_unchecked (_RanIt _First, _RanIt _Mid, _RanIt _Last)
template<class _RanIt >
void	cliext::partial_sort (_RanIt _First, _RanIt _Mid, _RanIt _Last)
template<class _RanIt , class _Pr >
void	cliext::partial_sort_unchecked (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::partial_sort (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _InIt , class _RanIt >
_RanIt	cliext::partial_sort_copy_unchecked (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2)
template<class _InIt , class _RanIt >
_RanIt	cliext::partial_sort_copy (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2)
template<class _InIt , class _RanIt , class _Pr >
_RanIt	cliext::partial_sort_copy_unchecked (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred)
template<class _InIt , class _RanIt , class _Pr >
_RanIt	cliext::partial_sort_copy (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred)
template<class _RanIt >
void	cliext::nth_element_unchecked (_RanIt _First, _RanIt _Nth, _RanIt _Last)
template<class _RanIt >
void	cliext::nth_element (_RanIt _First, _RanIt _Nth, _RanIt _Last)
template<class _RanIt , class _Pr >
void	cliext::nth_element_unchecked (_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	cliext::nth_element (_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred)
template<class _InIt1 , class _InIt2 >
bool	cliext::includes_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
template<class _InIt1 , class _InIt2 >
bool	cliext::includes (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	cliext::includes_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	cliext::includes (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	cliext::set_union_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	cliext::set_union (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	cliext::set_union_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	cliext::set_union (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	cliext::set_intersection_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	cliext::set_intersection (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	cliext::set_intersection_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	cliext::set_intersection (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	cliext::set_difference_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	cliext::set_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	cliext::set_difference_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	cliext::set_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	cliext::set_symmetric_difference_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	cliext::set_symmetric_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	cliext::set_symmetric_difference_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	cliext::set_symmetric_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _FwdIt >
_FwdIt	cliext::max_element_unchecked (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt >
_FwdIt	cliext::max_element (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	cliext::max_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	cliext::max_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	cliext::min_element_unchecked (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt >
_FwdIt	cliext::min_element (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	cliext::min_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	cliext::min_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _BidIt >
bool	cliext::next_permutation_unchecked (_BidIt _First, _BidIt _Last)
template<class _BidIt >
bool	cliext::next_permutation (_BidIt _First, _BidIt _Last)
template<class _BidIt , class _Pr >
bool	cliext::next_permutation_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
bool	cliext::next_permutation (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt >
bool	cliext::prev_permutation_unchecked (_BidIt _First, _BidIt _Last)
template<class _BidIt >
bool	cliext::prev_permutation (_BidIt _First, _BidIt _Last)
template<class _BidIt , class _Pr >
bool	cliext::prev_permutation_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
bool	cliext::prev_permutation (_BidIt _First, _BidIt _Last, _Pr _Pred)

Variables
_STD_BEGIN const int	_ISORT_MAX = 32
constexpr const _Ty &()	_Left
constexpr const _Ty &()	_Right
constexpr const _Ty &()	_Right
constexpr const _Ty &()	_Left
_FwdIt	cliext::_Last
_FwdIt const _Ty	cliext::_Val
_Diff	cliext::_Count = 0
_FwdIt const _Ty _Pr	cliext::_Pred
_RanIt	cliext::_Pfirst = _Mid
_RanIt	cliext::_Plast = _Pfirst + 1
_RanIt	cliext::_Gfirst = _Plast
_RanIt	cliext::_Glast = _Pfirst

Macro Definition Documentation

#define _ALGORITHM_

#define _CLI_ALGORITHM_

#define _DEBUG_HEAP_PRED	(		first,
			last,
			pred
	)

#define _STLCLRDB_HEAP	(		first,
			last
	)

#define _STLCLRDB_HEAP_PRED	(		first,
			last,
			pred
	)

Function Documentation

template<class _FwdIt , class _Pr >

_FwdIt _Adjacent_find_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr &  _Pred  )

inline

    {   // find first matching successor
    for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
        if (*_Firstb == *_First)
            return (_Firstb);
    return (_Last);
    }

template<class _InIt , class _Pr >

bool _All_of_unchecked ( _InIt  _First, _InIt  _Last, _Pr &  _Pred  )

inline

        {   // enough room, look for a match
        if (*_First1 == _Val)
            {   // found part of possible match, check it out

template<class _InIt , class _Pr >

bool _Any_of_unchecked ( _InIt  _First, _InIt  _Last, _Pr &  _Pred  )

inline

            {   // no match, take big jump and back up as needed
            _Oldfirst1 = _First1 + 1;

template<class _FwdIt , class _Ty , class _Pr >

bool _Binary_search_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr &  _Pred  )

inline

    {   // merge [_First, _Mid) with [_Mid, _Last), using operator<

template<class _BidIt1 , class _BidIt2 , class _BidIt3 , class _Pr >

_BidIt3 _Buffered_merge_backward_unchecked ( _BidIt1  _First1, _BidIt1  _Last1, _BidIt2  _First2, _BidIt2  _Last2, _BidIt3  _Dest, _Pr &  _Pred, bool  _In_place = false  )

inline

    {   // merge [_First, _Mid) with [_Mid, _Last), using _Pred
    typedef iterator_traits<_BidIt>::difference_type _Diff;
    typedef iterator_traits<_BidIt>::value_type _Ty;

    if (_First != _Mid && _Mid != _Last)
        {   // merge nontrivial sequence
        _Diff _Count1 = 0;
        _Iter_distance(_First, _Mid, _Count1);
        _Diff _Count2 = 0;
        _Iter_distance(_Mid, _Last, _Count2);
        _TEMP_ITER(_BidIt, _Ty)
            _Tempbuf(_Count1 < _Count2 ? _Count1 : _Count2);
        cliext::_XBuffered_merge(_First, _Mid, _Last,
            _Count1, _Count2, _Tempbuf, _Pred);
        }

template<class _BidIt , class _Diff , class _Ty , class _Pr >

void _Buffered_merge_sort_unchecked ( _BidIt  _First, _BidIt  _Last, _Diff  _Count, _Temp_iterator< _Ty > &  _Tempbuf, _Pr &  _Pred  )

inline

    {   // order [_First, _Last), using _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    cliext::sort_unchecked(_Unchecked(_First), _Unchecked(_Last), _Pred);
    }

        // TEMPLATE FUNCTION stable_sort
template<class _BidIt,
    class _OutIt,
    class _Diff> inline
    void _XChunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
        _Diff _Chunk, _Diff _Count)
    {   // copy merging chunks, using operator<
    for (_Diff _Chunk2 = _Chunk * 2; _Chunk2 <= _Count; _Count -= _Chunk2)
        {   // copy merging pairs of adjacent chunks
        _BidIt _Mid1 = _First;
        cliext::advance(_Mid1, _Chunk);
        _BidIt _Mid2 = _Mid1;

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

_OutIt _Buffered_merge_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred, bool  _In_place = false  )

inline

    {   // merge [_First, _Mid) with [_Mid, _Last), using _Pred
    _STLCLRDB_ORDER_PRED(_First, _Mid, _Pred);
    _STLCLRDB_ORDER_PRED(_Mid, _Last, _Pred);
    cliext::inplace_merge_unchecked(
        _Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last), _Pred);
    }

        // TEMPLATE FUNCTION sort
template<class _BidIt> inline
    void _XInsertion_sort(_BidIt _First, _BidIt _Last)
    {   // insertion sort [_First, _Last), using operator<
    typedef iterator_traits<_BidIt>::value_type _Ty;

    if (_First != _Last)
        for (_BidIt _Next = _First; ++_Next != _Last; )
            {   // order next element
            _BidIt _Next1 = _Next;
            _Ty _Val = *_Next;

            if (_STLCLRDB_LT(_Val, *_First))
                {   // found new earliest element, move to front
                cliext::copy_backward_unchecked(_First, _Next, ++_Next1);
                *_First = _Val;
                }
            else

template<class _BidIt , class _Diff , class _Ty , class _Pr >

void _Buffered_merge_unchecked ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last, _Diff  _Count1, _Diff  _Count2, _Temp_iterator< _Ty > &  _Tempbuf, _Pr &  _Pred  )

inline

    {   // sort median of three elements to middle
    if (_STLCLRDB_LT(*_Mid, *_First))
        cliext::iter_swap(_Mid, _First);
    if (_STLCLRDB_LT(*_Last, *_Mid))
        cliext::iter_swap(_Last, _Mid);
    if (_STLCLRDB_LT(*_Mid, *_First))
        cliext::iter_swap(_Mid, _First);
    }

template<class _RanIt> inline
    void _XMedian(_RanIt _First, _RanIt _Mid, _RanIt _Last)
    {   // sort median element to middle
    if (40 < _Last - _First)
        {   // median of nine
        int _Step = (int)(_Last - _First + 1) / 8;
        cliext::_XMed3(_First, _First + _Step, _First + 2 * _Step);
        cliext::_XMed3(_Mid - _Step, _Mid, _Mid + _Step);
        cliext::_XMed3(_Last - 2 * _Step, _Last - _Step, _Last);
        cliext::_XMed3(_First + _Step, _Mid, _Last - _Step);
        }
    else
        cliext::_XMed3(_First, _Mid, _Last);
    }

template<class _RanIt> inline
    _PAIR_TYPE(_RanIt) _XUnguarded_partition(_RanIt _First, _RanIt _Last)
    {   // partition [_First, _Last), using operator<
    _RanIt _Mid = _First + (_Last - _First) / 2;    // sort median to _Mid
    cliext::_XMedian(_First, _Mid, _Last - 1);
    _RanIt _Pfirst = _Mid;
    _RanIt _Plast = _Pfirst + 1;

    while (_First < _Pfirst
        && !_STLCLRDB_LT(*(_Pfirst - 1), *_Pfirst)
        && !(*_Pfirst < *(_Pfirst - 1)))
        --_Pfirst;
    while (_Plast < _Last
        && !_STLCLRDB_LT(*_Plast, *_Pfirst)
        && !(*_Pfirst < *_Plast))
        ++_Plast;

    _RanIt _Gfirst = _Plast;
    _RanIt _Glast = _Pfirst;

template<class _BidIt , class _Diff , class _Ty >

_BidIt _Buffered_rotate_unchecked ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last, _Diff  _Count1, _Diff  _Count2, _Temp_iterator< _Ty > &  _Tempbuf  )

inline

    {   // find first element that _Val is before, using operator<
    typedef iterator_traits<_FwdIt>::difference_type _Diff;

    _Diff _Count = 0;
    _Iter_distance(_First, _Last, _Count);
    for (; 0 < _Count; )
        {   // divide and conquer, find half that contains answer
        _Diff _Count2 = _Count / 2;
        _FwdIt _Mid = _First;
        cliext::advance(_Mid, _Count2);

        if (!_STLCLRDB_LT(_Val, *_Mid))
            _First = ++_Mid, _Count -= _Count2 + 1;
        else
            _Count = _Count2;
        }
    return (_First);
    }

template<class _FwdIt,
    class _Ty> inline
    _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty% _Val)
    {   // find first element that _Val is before, using operator<
    _STLCLRDB_ORDER(_First, _Last);
    return (cliext::upper_bound_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Val));

template<class _BidIt , class _OutIt , class _Diff , class _Pr >

void _Chunked_merge_unchecked ( _BidIt  _First, _BidIt  _Last, _OutIt  _Dest, _Diff  _Chunk, _Diff  _Count, _Pr &  _Pred  )

inline

            {   // loop on second half
            cliext::_XSort(_First, _Mid.first, _Ideal, _Pred);
            _First = _Mid.second;
            }
        else
            {   // loop on first half
            cliext::_XSort(_Mid.second, _Last, _Ideal, _Pred);
            _Last = _Mid.first;
            }
        }

    if (_ISort::_Max < _Count)
        {   // heap sort if too many divisions
        cliext::make_heap_unchecked(_First, _Last, _Pred);
        cliext::sort_heap_unchecked(_First, _Last, _Pred);
        }
    else if (1 < _Count)
        cliext::_XInsertion_sort(_First, _Last, _Pred); // small
    }

template<class _RanIt,

template<class _InIt , class _OutIt , class _Pr >

_OutIt _Copy_if_no_deprecate ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred  )

inline

            {   // no match, take big jump and back up as needed

template<class _InIt , class _OutIt , class _Pr >

_OutIt _Copy_if_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred  )

inline

    {   // find first _Count * _Val satisfying _Pred, random-access iterators
    if (_Count <= 0)
        return (_First1);

    _FwdIt1 _Oldfirst1 = _First1;
    for (; _Count <= _Last1 - _Oldfirst1; )
        {   // enough room, look for a match
        if (_Pred(*_First1, _Val))
            {   // found part of possible match, check it out
            _Diff2 _Count1 = _Count;
            _FwdIt1 _Mid1  = _First1;

template<class _InIt , class _Pr >

iterator_traits<_InIt>::difference_type _Count_if_unchecked ( _InIt  _First, _InIt  _Last, _Pr &  _Pred  )

inline

    {   // find first satisfying _Pred with successor
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::adjacent_find_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Pred));
    }

        // TEMPLATE FUNCTION count

template<class _FwdIt , class _Ty , class _Pr >

pair<_FwdIt, _FwdIt> _Equal_range_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr &  _Pred  )

inline

    {   // merge [_First, _Mid) with [_Mid, _Last), using operator<
    if (_Count1 + _Count2 == 2)
        {   // order two one-element partitions
        if (_STLCLRDB_LT(*_Mid, *_First))
            cliext::iter_swap(_First, _Mid);
        }
    else if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())
        {   // buffer left partition, then merge
        cliext::copy_unchecked(_First, _Mid, _Tempbuf._Init());
        cliext::merge_unchecked(_Tempbuf._First(), _Tempbuf._Last(),
            _Mid, _Last, _First);
        }
    else if (_Count2 <= _Tempbuf._Maxlen())
        {   // buffer right partition, then merge
        cliext::copy_unchecked(_Mid, _Last, _Tempbuf._Init());
        cliext::_XMerge_backward(_First, _Mid,

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

    {   // replace [_First, _Last) with _Func()
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Func);
    cliext::generate_unchecked(_Unchecked(_First), _Unchecked(_Last), _Func);
    }

        // TEMPLATE FUNCTION generate_n
template<class _OutIt,
    class _Diff,
    class _Fn0> inline
    void generate_n_unchecked(_OutIt _Dest, _Diff _Count, _Fn0 _Func)
    {   // replace [_Dest, _Dest + _Count) with _Func()
    for (; 0 < _Count; --_Count, ++_Dest)
        *_Dest = _Func();
    }

template<class _OutIt,
    class _Diff,
    class _Fn0> inline
    void generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func)
    {   // replace [_Dest, _Dest + _Count) with _Func()
    _STLCLRDB_POINTER(_Dest);
    _STLCLRDB_POINTER(_Func);
    cliext::generate_n_unchecked(_Unchecked(_Dest), _Count, _Func);

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

    {   // copy omitting each element satisfying _Pred
    for (; _First != _Last; ++_First)
        if (!_Pred(*_First))

template<class _InIt , class _Pr >

_InIt _Find_if_not_unchecked ( _InIt  _First, _InIt  _Last, _Pr &  _Pred  )

inline

    {   // find first _Count * _Val satisfying _Pred, random-access iterators

template<class _InIt , class _Pr >

_InIt _Find_if_unchecked ( _InIt  _First, _InIt  _Last, _Pr &  _Pred  )

inline

    {   // find first satisfying _Pred
    for (; _First != _Last; ++_First)
        if (_Pred(*_First))
            break;
    return (_First);

template<class _InIt , class _Fn1 >

void _For_each_unchecked ( _InIt  _First, _InIt  _Last, _Fn1 &  _Func  )

inline

                                : _First);
    }

template<class _OutIt , class _Diff , class _Fn0 >

_OutIt _Generate_n_unchecked ( _OutIt  _Dest, _Diff  _Count, _Fn0 &  _Func  )

inline

    {   // move elements satisfying _Pred to beginning of sequence

template<class _FwdIt , class _Fn0 >

void _Generate_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Fn0 &  _Func  )

inline

    {   // move elements satisfying _Pred to beginning of sequence
    for (; ; ++_First)

template<class _RanIt , class _Pr >

void _Guess_median_unchecked ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, _Pr &  _Pred  )

inline

    {   // order [_First, _Last), using operator<
    _STLCLRDB_RANGE(_First, _Last);
    cliext::sort_unchecked(_Unchecked(_First), _Unchecked(_Last));
    }

        // TEMPLATE FUNCTION sort WITH PRED
template<class _BidIt,
    class _Pr> inline
    void _XInsertion_sort(_BidIt _First, _BidIt _Last, _Pr _Pred)
    {   // insertion sort [_First, _Last), using _Pred
    typedef iterator_traits<_BidIt>::value_type _Ty;

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

    {   // sort using temp buffer for merges, using _Pred
    _BidIt _Mid = _First;
    for (_Diff _Nleft = _Count; _ISort::_Max <= _Nleft; _Nleft -= _ISort::_Max)
        {   // sort chunks
        _BidIt _Midn = _Mid;
        cliext::advance(_Midn, (int)_ISort::_Max);

template<class _BidIt , class _Pr >

void _Inplace_merge_unchecked ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last, _Pr &  _Pred  )

inline

template<class _BidIt , class _Pr >

void _Insertion_sort_unchecked ( _BidIt  _First, _BidIt  _Last, _Pr &  _Pred  )

inline

    {   // order [_First, _Last), using operator<
    _Diff _Count;
    for (; _ISort::_Max < (_Count = _Last - _First) && 0 < _Ideal; )
        {   // divide and conquer by quicksort
        _PAIR_TYPE(_RanIt) _Mid =
            cliext::_XUnguarded_partition(_First, _Last);
        _Ideal /= 2, _Ideal += _Ideal / 2;  // allow 1.5 log2(N) divisions

        if (_Mid.first - _First < _Last - _Mid.second)
            {   // loop on second half
            cliext::_XSort(_First, _Mid.first, _Ideal);
            _First = _Mid.second;
            }
        else
            {   // loop on first half
            cliext::_XSort(_Mid.second, _Last, _Ideal);
            _Last = _Mid.first;
            }

template<class _RanIt , class _Pr >

_RanIt _Is_heap_until_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr &  _Pred  )

inline

    {   // find smallest element, using _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::min_element_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Pred));
    }

template<class _InIt , class _Pr >

bool _Is_partitioned_unchecked ( _InIt  _First, _InIt  _Last, _Pr &  _Pred  )

inline

    {   // look for one of [_First2, _Last2) that matches element
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_RANGE(_First2, _Last2);
    return (cliext::find_first_of_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2)));
    }

        // TEMPLATE FUNCTION find_first_of WITH PRED
template<class _FwdIt1,

template<class _FwdIt , class _Pr >

_FwdIt _Is_sorted_until_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr &  _Pred  )

inline

    {   // permute and test for pure ascending, using _Pred

template<class _FwdIt , class _Ty , class _Pr >

_FwdIt _Lower_bound_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr &  _Pred  )

inline

    {   // rotate [_First, _Last) using temp buffer
    if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())
        {   // buffer left partition, then copy parts
        cliext::copy_unchecked(_First, _Mid, _Tempbuf._Init());
        cliext::copy_unchecked(_Mid, _Last, _First);
        return (cliext::copy_backward_unchecked(
            _Tempbuf._First(), _Tempbuf._Last(), _Last));
        }
    else if (_Count2 <= _Tempbuf._Maxlen())
        {   // buffer right partition, then copy parts
        cliext::copy_unchecked(_Mid, _Last, _Tempbuf._Init());
        cliext::copy_backward_unchecked(_First, _Mid, _Last);
        return (cliext::copy_unchecked(
            _Tempbuf._First(), _Tempbuf._Last(), _First));
        }
    else
        {   // buffer too small, rotate in place
        cliext::rotate_unchecked(_First, _Mid, _Last);
        cliext::advance(_First, _Count2);

template<class _RanIt , class _Pr >

void _Make_heap_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr &  _Pred  )

inline

    {   //  copy merging ranges, both using _Pred
    for (; _First1 != _Last1 && _First2 != _Last2; ++_Dest)
        if (_STLCLRDB_LT_PRED(_Pred, *_First2, *_First1))
            *_Dest = *_First2, ++_First2;
        else
            *_Dest = *_First1, ++_First1;

    _Dest = cliext::copy_unchecked(_First1, _Last1, _Dest); // copy any tail
    return (cliext::copy_unchecked(_First2, _Last2, _Dest));
    }

template<class _InIt1,
    class _InIt2,

template<class _FwdIt , class _Pr >

_FwdIt _Max_element_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr &  _Pred  )

inline

    {   // OR sets [_First1, _Last1) and [_First2, _Last2), using operator<

template<class _RanIt , class _Pr >

void _Med3_unchecked ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, _Pr &  _Pred  )

inline

        {   // heap sort if too many divisions
        cliext::make_heap_unchecked(_First, _Last);
        cliext::sort_heap_unchecked(_First, _Last);
        }
    else if (1 < _Count)
        cliext::_XInsertion_sort(_First, _Last);    // small
    }

template<class _RanIt> inline
    void sort_unchecked(_RanIt _First, _RanIt _Last)
    {   // order [_First, _Last), using operator<

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

_OutIt _Merge_no_deprecate ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred  )

inline

            {   // right larger, cut it in half and partition left to match
            _Count1n = 0, _Count2n = _Count2 / 2;
            _Lastn = _Mid;
            cliext::advance(_Lastn, _Count2n);
            _Firstn = cliext::upper_bound_unchecked(_First, _Mid,

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

_OutIt _Merge_no_deprecate1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred, input_iterator_tag  , input_iterator_tag  , _Any_tag    )

inline

    {   // merge [_First, _Mid) with [_Mid, _Last), using _Pred
    if (_Count1 + _Count2 == 2)
        {   // order two one-element partitions
        if (_STLCLRDB_LT_PRED(_Pred, *_Mid, *_First))
            cliext::iter_swap(_First, _Mid);
        }

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

_OutIt _Merge_no_deprecate1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred, random_access_iterator_tag  , random_access_iterator_tag  , random_access_iterator_tag    )

inline

        {   // buffer right partition, then merge
        cliext::copy_unchecked(_Mid, _Last, _Tempbuf._Init());
        cliext::_XMerge_backward(_First, _Mid,
            _Tempbuf._First(), _Tempbuf._Last(), _Last, _Pred);
        }
    else
        {   // buffer too small, divide and conquer

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

_OutIt _Merge_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred  )

inline

    {   // merge backwards to _Dest, using _Pred
    for (; ; )
        if (_First1 == _Last1)
            return (cliext::copy_backward_unchecked(_First2, _Last2, _Dest));
        else if (_First2 == _Last2)
            return (cliext::copy_backward_unchecked(_First1, _Last1, _Dest));
        else if (_STLCLRDB_LT_PRED(_Pred, *--_Last2, *--_Last1))
            *--_Dest = *_Last1, ++_Last2;
        else
            *--_Dest = *_Last2, ++_Last1;
    }

template<class _FwdIt , class _Pr >

_FwdIt _Min_element_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr &  _Pred  )

inline

    {   // OR sets [_First1, _Last1) and [_First2, _Last2), using _Pred

template<class _FwdIt , class _Pr >

pair<_FwdIt, _FwdIt> _Minmax_element_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr &  _Pred  )

inline

    {   // AND sets [_First1, _Last1) and [_First2, _Last2), using operator<
    for (; _First1 != _Last1 && _First2 != _Last2; )
        if (_STLCLRDB_LT(*_First1, *_First2))
            ++_First1;
        else if (*_First2 < *_First1)
            ++_First2;
        else
            *_Dest++ = *_First1++, ++_First2;
    return (_Dest);
    }

template<class _InIt1,
    class _InIt2,
    class _OutIt> inline
    _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
    {   // AND sets [_First1, _Last1) and [_First2, _Last2), using operator<
    _STLCLRDB_ORDER(_First1, _Last1);
    _STLCLRDB_ORDER(_First2, _Last2);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::set_intersection_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest)));
    }

        // TEMPLATE FUNCTION set_intersection WITH PRED
template<class _InIt1,
    class _InIt2,
    class _OutIt,
    class _Pr> inline
    _OutIt set_intersection_unchecked(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
    {   // AND sets [_First1, _Last1) and [_First2, _Last2), using _Pred
    for (; _First1 != _Last1 && _First2 != _Last2; )
        if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
            ++_First1;

template<class _InIt1 , class _InIt2 , class _Pr >

pair<_InIt1, _InIt2> _Mismatch_no_deprecate ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr &  _Pred  )

inline

    {   // find first [_First2, _Last2) match
    typedef iterator_traits<_FwdIt1>::difference_type _Diff1;
    typedef iterator_traits<_FwdIt2>::difference_type _Diff2;

    _Diff1 _Count1 = 0;
    _Iter_distance(_First1, _Last1, _Count1);
    _Diff2 _Count2 = 0;
    _Iter_distance(_First2, _Last2, _Count2);

template<class _InIt1 , class _InIt2 , class _Pr >

auto _Mismatch_no_deprecate1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr &  _Pred, input_iterator_tag  , input_iterator_tag    ) -> pair<_InIt1, decltype(_Unchecked_idl0(_First2))>

inline

template<class _InIt1 , class _InIt2 , class _Pr >

pair<_InIt1, _UNCHECKED_TYPE(_InIt2)> _Mismatch_no_deprecate1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr &  _Pred, random_access_iterator_tag  , random_access_iterator_tag    )

inline

    {   // find first [_First2, _Last2) match

template<class _InIt1 , class _InIt2 , class _Pr >

pair<_InIt1, _InIt2> _Mismatch_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr &  _Pred  )

inline

    {   // count elements that match _Val
    _STLCLRDB_RANGE(_First, _Last);
    return (cliext::count_unchecked(_Unchecked(_First), _Unchecked(_Last),
        _Val));
    }

        // TEMPLATE FUNCTION count_if
template<class _InIt,
    class _Pr> inline

template<class _InIt1 , class _InIt2 , class _Pr >

pair<_InIt1, _InIt2> _Mismatch_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr &  _Pred  )

inline

    {   // find first _Count * _Val match, forward iterators

template<class _BidIt , class _Pr >

bool _Next_permutation_unchecked ( _BidIt  _First, _BidIt  _Last, _Pr &  _Pred  )

inline

    {   // XOR sets [_First1, _Last1) and [_First2, _Last2), using _Pred
    _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
    _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::set_symmetric_difference_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest), _Pred));
    }

        // TEMPLATE FUNCTION max_element
template<class _FwdIt> inline
    _FwdIt max_element_unchecked(_FwdIt _First, _FwdIt _Last)
    {   // find largest element, using operator<
    _FwdIt _Found = _First;
    if (_First != _Last)
        for (; ++_First != _Last; )
            if (_STLCLRDB_LT(*_Found, *_First))
                _Found = _First;
    return (_Found);

const _Ty& _Right _NOEXCEPT_OP

(

_NOEXCEPT_OP(_DEBUG_LT(_Left, _Right))

)

    {   // take set [_First2, _Last2) from [_First1, _Last1), using operator<
    _STLCLRDB_ORDER(_First1, _Last1);
    _STLCLRDB_ORDER(_First2, _Last2);
    _STLCLRDB_POINTER(_Dest);

const _Ty& _Right _NOEXCEPT_OP

(

_NOEXCEPT_OP(_DEBUG_LT(_Right, _Left))

)

    {   // XOR sets [_First1, _Last1) and [_First2, _Last2), using operator<

template<class _InIt , class _Pr >

bool _None_of_unchecked ( _InIt  _First, _InIt  _Last, _Pr &  _Pred  )

inline

    {   // find first _Count * _Val satisfying _Pred, forward iterators

template<class _RanIt , class _Pr >

void _Nth_element_unchecked ( _RanIt  _First, _RanIt  _Nth, _RanIt  _Last, _Pr &  _Pred  )

inline

    {   // sort preserving order of equivalents, using operator<
    _STLCLRDB_RANGE(_First, _Last);
    cliext::stable_sort_unchecked(_Unchecked(_First), _Unchecked(_Last));
    }

        // TEMPLATE FUNCTION stable_sort WITH PRED
template<class _BidIt,
    class _OutIt,
    class _Diff,
    class _Pr> inline
    void _XChunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,

template<class _InIt , class _RanIt , class _Pr >

_RanIt _Partial_sort_copy_unchecked ( _InIt  _First1, _InIt  _Last1, _RanIt  _First2, _RanIt  _Last2, _Pr &  _Pred  )

inline

    {   //  sort preserving order of equivalents, using operator<
    if (_Count <= _ISort::_Max)
        cliext::_XInsertion_sort(_First, _Last);    // small
    else
        {   // sort halves and merge
        _Diff _Count2 = (_Count + 1) / 2;
        _BidIt _Mid = _First;
        cliext::advance(_Mid, _Count2);

template<class _RanIt , class _Pr >

void _Partial_sort_unchecked ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, _Pr &  _Pred  )

inline

        {   // merge adjacent pairs of chunks to and from temp buffer
        cliext::_XChunked_merge(_First, _Last, _Tempbuf._Init(),
            _Chunk, _Count);
        cliext::_XChunked_merge(_Tempbuf._First(), _Tempbuf._Last(), _First,
            _Chunk *= 2, _Count);
        }
    }
#endif  // __cplusplus_cli

template<class _BidIt,
    class _Diff,
    class _Ty> inline
    void _XStable_sort(_BidIt _First, _BidIt _Last, _Diff _Count,

template<class _RanIt , class _Pr >

pair<_RanIt, _RanIt> _Partition_by_median_guess_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr &  _Pred  )

inline

                {   // found new earliest element, move to front
                cliext::copy_backward_unchecked(_First, _Next, ++_Next1);
                *_First = _Val;
                }
            else
                {   // look for insertion point after first
                for (_BidIt _First1 = _Next1;
                    _STLCLRDB_LT_PRED(_Pred, _Val, *--_First1);
                    _Next1 = _First1)
                    *_Next1 = *_First1; // move hole down
                *_Next1 = _Val; // insert element in hole
                }
            }
    }

template<class _RanIt,
    class _Pr> inline
    void _XMed3(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
    {   // sort median of three elements to middle
    if (_STLCLRDB_LT_PRED(_Pred, *_Mid, *_First))
        cliext::iter_swap(_Mid, _First);
    if (_STLCLRDB_LT_PRED(_Pred, *_Last, *_Mid))
        cliext::iter_swap(_Last, _Mid);
    if (_STLCLRDB_LT_PRED(_Pred, *_Mid, *_First))
        cliext::iter_swap(_Mid, _First);
    }

template<class _RanIt,
    class _Pr> inline
    void _XMedian(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
    {   // sort median element to middle
    if (40 < _Last - _First)
        {   // median of nine
        int _Step = (int)(_Last - _First + 1) / 8;
        cliext::_XMed3(_First, _First + _Step, _First + 2 * _Step, _Pred);
        cliext::_XMed3(_Mid - _Step, _Mid, _Mid + _Step, _Pred);
        cliext::_XMed3(_Last - 2 * _Step, _Last - _Step, _Last, _Pred);
        cliext::_XMed3(_First + _Step, _Mid, _Last - _Step, _Pred);
        }
    else
        cliext::_XMed3(_First, _Mid, _Last, _Pred);
    }

template<class _RanIt,
    class _Pr> inline
    _PAIR_TYPE(_RanIt) _XUnguarded_partition(_RanIt _First, _RanIt _Last,
        _Pr _Pred)
    {   // partition [_First, _Last), using _Pred
    _RanIt _Mid = _First + (_Last - _First) / 2;
    cliext::_XMedian(_First, _Mid, _Last - 1, _Pred);
    _RanIt _Pfirst = _Mid;

template<class _InIt , class _OutIt1 , class _OutIt2 , class _Pr >

pair<_OutIt1, _OutIt2> _Partition_copy_no_deprecate ( _InIt  _First, _InIt  _Last, _OutIt1  _Dest1, _OutIt2  _Dest2, _Pr &  _Pred  )

inline

    {   // find last [_First2, _Last2) match
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_RANGE(_First2, _Last2);
    return (cliext::find_end_unchecked(

template<class _InIt , class _OutIt1 , class _OutIt2 , class _Pr >

pair<_OutIt1, _OutIt2> _Partition_copy_unchecked ( _InIt  _First, _InIt  _Last, _OutIt1  _Dest1, _OutIt2  _Dest2, _Pr &  _Pred  )

inline

            {   // room for match, try it
            _FwdIt1 _Mid1 = _First1;
            for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1)
                if (!(*_Mid1 == *_Mid2))
                    break;
                else if (++_Mid2 == _Last2)
                    {   // potential answer, save it
                    _Ans = _First1;

template<class _FwdIt , class _Pr >

_FwdIt _Partition_point_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr &  _Pred  )

inline

    {   // look for one of [_First2, _Last2) satisfying _Pred with element
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_RANGE(_First2, _Last2);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::find_first_of_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Pred));
    }

        // TEMPLATE FUNCTION iter_swap
template<class _FwdIt1,
    class _FwdIt2> inline
    void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
    {   // swap *_Left and *_Right
    cliext::swap(*_Left, *_Right);
    }

template<class _FwdIt , class _Pr >

_FwdIt _Partition_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr &  _Pred, forward_iterator_tag    )

inline

    {   // find first element not before _Val, using operator<
    _STLCLRDB_ORDER(_First, _Last);
    return (cliext::lower_bound_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Val));
    }

        // TEMPLATE FUNCTION lower_bound WITH PRED
template<class _FwdIt,
    class _Ty,

template<class _BidIt , class _Pr >

_BidIt _Partition_unchecked ( _BidIt  _First, _BidIt  _Last, _Pr &  _Pred, bidirectional_iterator_tag    )

inline

    {   // find first element not before _Val, using _Pred
    typedef iterator_traits<_FwdIt>::difference_type _Diff;

    _Diff _Count = 0;
    _Iter_distance(_First, _Last, _Count);
    for (; 0 < _Count; )
        {   // divide and conquer, find half that contains answer
        _Diff _Count2 = _Count / 2;
        _FwdIt _Mid = _First;
        cliext::advance(_Mid, _Count2);

        if (_STLCLRDB_LT_PRED(_Pred, *_Mid, _Val))
            _First = ++_Mid, _Count -= _Count2 + 1;
        else
            _Count = _Count2;
        }
    return (_First);
    }

template<class _FwdIt,

template<class _RanIt , class _Diff , class _Ty , class _Pr >

void _Pop_heap_hole_by_index ( _RanIt  _First, _Diff  _Hole, _Diff  _Bottom, _Ty &&  _Val, _Pr &  _Pred  )

inline

    {   // test if _Val equivalent to some element, using operator<
    _STLCLRDB_ORDER(_First, _Last);
    return (cliext::binary_search_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Val));
    }

        // TEMPLATE FUNCTION binary_search WITH PRED
template<class _FwdIt,
    class _Ty,
    class _Pr> inline
    bool binary_search_unchecked(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred)
    {   // test if _Val equivalent to some element, using _Pred
    _First = cliext::lower_bound_unchecked(_First, _Last, _Val, _Pred);
    return (_First != _Last && !_Pred(_Val, *_First));
    }

template<class _FwdIt,
    class _Ty,
    class _Pr> inline

template<class _RanIt , class _Ty , class _Pr >

void _Pop_heap_hole_unchecked ( _RanIt  _First, _RanIt  _Last, _RanIt  _Dest, _Ty &&  _Val, _Pr &  _Pred  )

inline

    {   // copy merging ranges, both using operator<

template<class _RanIt , class _Pr >

void _Pop_heap_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr &  _Pred  )

inline

    {   // copy merging ranges, both using operator<

template<class _Ty >

_Post_equal_to_ ( ) const

inline

template<class _Ty >

_Post_equal_to_ ( ) const

inline

template<class _BidIt , class _Pr >

bool _Prev_permutation_unchecked ( _BidIt  _First, _BidIt  _Last, _Pr &  _Pred  )

inline

    {   // find largest element, using _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::max_element_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Pred));
    }

        // TEMPLATE FUNCTION min_element
template<class _FwdIt> inline
    _FwdIt min_element_unchecked(_FwdIt _First, _FwdIt _Last)
    {   // find smallest element, using operator<
    _FwdIt _Found = _First;
    if (_First != _Last)
        for (; ++_First != _Last; )
            if (_STLCLRDB_LT(*_First, *_Found))
                _Found = _First;
    return (_Found);
    }

template<class _RanIt , class _Diff , class _Ty , class _Pr >

void _Push_heap_by_index ( _RanIt  _First, _Diff  _Hole, _Diff  _Top, _Ty &&  _Val, _Pr &  _Pred  )

inline

        {   // divide and conquer, check midpoint
        _Diff _Count2 = _Count / 2;
        _FwdIt _Mid = _First;
        cliext::advance(_Mid, _Count2);

        if (_STLCLRDB_LT_PRED(_Pred, *_Mid, _Val))
            {   // range begins above _Mid, loop
            _First = ++_Mid;

template<class _RanIt , class _Pr >

void _Push_heap_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr &  _Pred  )

inline

            {   // range straddles _Mid, find each end and return
            _FwdIt _First2 = lower_bound(_First, _Mid, _Val, _Pred);
            cliext::advance(_First, _Count);
            _FwdIt _Last2 = upper_bound(++_Mid, _First, _Val, _Pred);
            return (_PAIR_TYPE(_FwdIt)(_First2, _Last2));
            }
        }

template<class _RanIt , class _Fn1 >

void _Random_shuffle1 ( _RanIt  _First, _RanIt  _Last, _Fn1 &  _Func  )

inline

    {   // order heap by repeatedly popping, using operator<
    for (; 1 < _Last - _First; --_Last)

template<class _RanIt , class _Fn1 >

void _Random_shuffle_unchecked ( _RanIt  _First, _RanIt  _Last, _Fn1 &  _Func  )

inline

    {   // make [_First, _Last) into a heap, using _Pred
    typedef iterator_traits<_RanIt>::difference_type _Diff;
    typedef iterator_traits<_RanIt>::value_type _Ty;

    if (1 < _Last - _First)
        {   // make nontrivial heap
        _Diff _Bottom = _Last - _First;

        for (_Diff _Hole = _Bottom / 2; 0 < _Hole; )
            {   // reheap top half, bottom to top
            --_Hole;
            cliext::_XAdjust_heap(_First, _Hole, _Bottom,
                _Ty(*(_First + _Hole)), _Pred);
            }
        }
    }

template<class _RanIt,
    class _Pr> inline
    void make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred)
    {   // make [_First, _Last) into a heap, using _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    cliext::make_heap_unchecked(_Unchecked(_First), _Unchecked(_Last),

template<class _Iter1 , class _Iter2 , class _UIter1 , class _UIter2 >

pair<_Iter1, _Iter2> _Rechecked_both ( _Iter1  _Dest1, _Iter2  _Dest2, pair< _UIter1, _UIter2 >  _Src  )

inline

    {   // perform function for each element
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Func);

template<class _InIt , class _OutIt , class _Pr >

_OutIt _Remove_copy_if_no_deprecate ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred  )

inline

    {   // partition preserving order of equivalents, using _Pred

template<class _InIt , class _OutIt , class _Pr >

_OutIt _Remove_copy_if_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred  )

inline

        {   // temp buffer not big enough, divide and conquer
        _BidIt _Mid = _First;
        cliext::advance(_Mid, _Count / 2);

        _BidIt _Left = cliext::_XStable_partition(_First, _Mid, _Pred,
            _Count / 2, _Tempbuf);  // form L1R1 in left half

template<class _InIt , class _OutIt , class _Ty >

_OutIt _Remove_copy_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, const _Ty &  _Val  )

inline

        {   // temp buffer not big enough, divide and conquer
        _BidIt _Mid = _First;
        cliext::advance(_Mid, _Count / 2);

        _BidIt _Left = cliext::_XStable_partition(_First, _Mid, _Pred,
            _Count / 2, _Tempbuf);  // form L1R1 in left half
        _BidIt _Right = cliext::_XStable_partition(_Mid, _Last, _Pred,

template<class _FwdIt , class _Pr >

_FwdIt _Remove_if_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr &  _Pred  )

inline

    {   // percolate _Hole to _Top or where _Val belongs, using operator<

template<class _FwdIt , class _Ty >

_FwdIt _Remove_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val  )

inline

    {   // test if range is a heap ordered by operator<
    typedef iterator_traits<_RanIt>::difference_type _Diff;

template<class _InIt , class _OutIt , class _Ty >

_OutIt _Replace_copy1 ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, const _Ty &  _Oldval, const _Ty &  _Newval, input_iterator_tag  , _Any_tag    )

inline

            {   // rotate each subcycle
            _RanIt _Hole = _First + _Count;
            _RanIt _Next = _Hole;

template<class _InIt , class _OutIt , class _Ty >

_OutIt _Replace_copy1 ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, const _Ty &  _Oldval, const _Ty &  _Newval, random_access_iterator_tag  , random_access_iterator_tag    )

inline

                    : _First + (_Shift - (_Last - _Next1));
                }
            *_Next = _Holeval;
            }
    }

template<class _InIt , class _OutIt , class _Pr , class _Ty >

_OutIt _Replace_copy_if_no_deprecate ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred, const _Ty &  _Val  )

inline

    {   // shuffle [_First, _Last)
    _STLCLRDB_RANGE(_First, _Last);

template<class _InIt , class _OutIt , class _Pr , class _Ty >

_OutIt _Replace_copy_if_no_deprecate1 ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred, const _Ty &  _Val, input_iterator_tag  , _Any_tag    )

inline

    {   // shuffle [_First, _Last)

template<class _InIt , class _OutIt , class _Pr , class _Ty >

_OutIt _Replace_copy_if_no_deprecate1 ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred, const _Ty &  _Val, random_access_iterator_tag  , random_access_iterator_tag    )

inline

            {   // assume unsigned long big enough for _Diff count
            unsigned long _Rm = _RANDOM_MAX;
            unsigned long _Rn = _Rand() & _RANDOM_MAX;
            for (; _Rm < _Index && _Rm != ~0UL;

template<class _InIt , class _OutIt , class _Pr , class _Ty >

_OutIt _Replace_copy_if_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred, const _Ty &  _Val  )

inline

    {   /* compute pseudo-random value */

template<class _InIt , class _OutIt , class _Ty >

_OutIt _Replace_copy_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, const _Ty &  _Oldval, const _Ty &  _Newval  )

inline

    {   // rotate [_First, _Last), random-access iterators
    typedef iterator_traits<_RanIt>::difference_type _Diff;
    typedef iterator_traits<_RanIt>::value_type _Ty;

    _Diff _Shift = _Mid - _First;
    _Diff _Count = _Last - _First;

template<class _FwdIt , class _Pr , class _Ty >

void _Replace_if_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr &  _Pred, const _Ty &  _Val  )

inline

    {   // rotate [_First, _Last), bidirectional iterators

template<class _FwdIt , class _Ty >

void _Replace_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Oldval, const _Ty &  _Newval  )

inline

    {   // copy reversing elements in [_First, _Last)

template<class _BidIt , class _OutIt >

_OutIt _Reverse_copy1 ( _BidIt  _First, _BidIt  _Last, _OutIt  _Dest, bidirectional_iterator_tag  , _Any_tag    )

inline

    {   // percolate _Hole to _Bottom, then push _Val, using _Pred
    _Diff _Top = _Hole;
    _Diff _Idx = 2 * _Hole + 2;

    for (; _Idx < _Bottom; _Idx = 2 * _Idx + 2)
        {   // move _Hole down to larger child

template<class _BidIt , class _OutIt >

_OutIt _Reverse_copy1 ( _BidIt  _First, _BidIt  _Last, _OutIt  _Dest, random_access_iterator_tag  , random_access_iterator_tag    )

inline

        {   // only child at bottom, move _Hole down to it
        *(_First + _Hole) = *(_First + (_Bottom - 1));
        _Hole = _Bottom - 1;
        }

template<class _BidIt , class _OutIt >

_OutIt _Reverse_copy_unchecked ( _BidIt  _First, _BidIt  _Last, _OutIt  _Dest  )

inline

    {   // percolate _Hole to _Bottom, then push _Val, using _Pred

template<class _FwdIt , class _OutIt >

_OutIt _Rotate_copy1 ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last, _OutIt  _Dest, forward_iterator_tag  , _Any_tag    )

inline

    {   // make [_First, _Last) into a heap, using operator<
    typedef iterator_traits<_RanIt>::difference_type _Diff;
    typedef iterator_traits<_RanIt>::value_type _Ty;

template<class _FwdIt , class _OutIt >

_OutIt _Rotate_copy1 ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last, _OutIt  _Dest, random_access_iterator_tag  , random_access_iterator_tag    )

inline

            {   // reheap top half, bottom to top
            --_Hole;
            cliext::_XAdjust_heap(_First, _Hole, _Bottom,
                _Ty(*(_First + _Hole)));

template<class _FwdIt , class _OutIt >

_OutIt _Rotate_copy_unchecked ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last, _OutIt  _Dest  )

inline

    {   // pop *_First to *(_Last - 1) and reheap, using _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    _STLCLRDB_HEAP_PRED(_First, _Last, _Pred);
    cliext::pop_heap_unchecked(_Unchecked(_First), _Unchecked(_Last),

template<class _FwdIt , class _Diff , class _Ty , class _Pr >

_FwdIt _Search_n_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Diff  _Count, const _Ty &  _Val, _Pr &  _Pred, forward_iterator_tag    )

inline

    {   // replace each matching _Oldval with _Newval
    _STLCLRDB_RANGE(_First, _Last);
    cliext::replace_unchecked(_Unchecked(_First), _Unchecked(_Last),
        _Oldval, _Newval);
    }

        // TEMPLATE FUNCTION replace_if
template<class _FwdIt,
    class _Pr,
    class _Ty> inline
    void replace_if_unchecked(_FwdIt _First, _FwdIt _Last,
        _Pr _Pred, const _Ty% _Val)
    {   // replace each satisfying _Pred with _Val
    for (; _First != _Last; ++_First)
        if (_Pred(*_First))
            *_First = _Val;
    }

template<class _FwdIt , class _Diff , class _Ty , class _Pr >

_FwdIt _Search_n_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Diff  _Count, const _Ty &  _Val, _Pr &  _Pred, random_access_iterator_tag    )

inline

    {   // replace each satisfying _Pred with _Val
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    cliext::replace_if_unchecked(_Unchecked(_First), _Unchecked(_Last),
        _Pred, _Val);
    }

        // TEMPLATE FUNCTION replace_copy
template<class _InIt,
    class _OutIt,
    class _Ty> inline
    _OutIt replace_copy_unchecked(_InIt _First, _InIt _Last,
        _OutIt _Dest, const _Ty% _Oldval, const _Ty% _Newval)
    {   // copy replacing each matching _Oldval with _Newval
    for (; _First != _Last; ++_First, ++_Dest)
        *_Dest = *_First == _Oldval ? _Newval : *_First;
    return (_Dest);
    }

template<class _InIt,
    class _OutIt,
    class _Ty> inline
    _OutIt replace_copy(_InIt _First, _InIt _Last,
        _OutIt _Dest, const _Ty% _Oldval, const _Ty% _Newval)
    {   // copy replacing each matching _Oldval with _Newval
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::replace_copy_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest), _Oldval, _Newval));
    }

        // TEMPLATE FUNCTION replace_copy_if
template<class _InIt,
    class _OutIt,
    class _Pr,
    class _Ty> inline
    _OutIt replace_copy_if_unchecked(_InIt _First, _InIt _Last,
        _OutIt _Dest, _Pr _Pred, const _Ty% _Val)
    {   // copy replacing each satisfying _Pred with _Val
    for (; _First != _Last; ++_First, ++_Dest)

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

    {   // swap [_First1, _Last1) with [_First2, ...)
    _STLCLRDB_RANGE(_First1, _Last1);
    return (cliext::swap_ranges_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2)));
    }

        // TEMPLATE FUNCTION transform WITH UNARY OP
template<class _InIt,
    class _OutIt,
    class _Fn1> inline
    _OutIt transform_unchecked(_InIt _First, _InIt _Last,
        _OutIt _Dest, _Fn1 _Func)
    {   // transform [_First, _Last) with _Func

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

    {   // transform [_First, _Last) with _Func
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    _STLCLRDB_POINTER(_Func);
    return (cliext::transform_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Dest, _Func));
    }

        // TEMPLATE FUNCTION transform WITH BINARY OP
template<class _InIt1,
    class _InIt2,
    class _OutIt,
    class _Fn2> inline

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

_OutIt _Set_difference_no_deprecate ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred  )

inline

    {   // copy [First1, _Last1) into [_First2, _Last2) using _Pred
    typedef iterator_traits<_RanIt>::difference_type _Diff;
    typedef iterator_traits<_InIt>::value_type _Ty;

    if (_First1 == _Last1 || _First2 == _Last2)
        return (_First2);
    else
        {   // copy and sort nontrivial

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

_OutIt _Set_difference_no_deprecate1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred  )

inline

    {   // copy [First1, _Last1) into [_First2, _Last2), using operator<
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_RANGE(_First2, _Last2);
    return (cliext::partial_sort_copy_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2)));

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

_OutIt _Set_intersection_no_deprecate ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred  )

inline

    {   // order [First, _Last) up to _Mid, using operator<

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

_OutIt _Set_intersection_no_deprecate1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred  )

inline

        {   // sort nontrivial sequence
        _Diff _Count = 0;
        _Iter_distance(_First, _Last, _Count);
        _TEMP_ITER(_BidIt, _Ty) _Tempbuf((_Count + 1) / 2);
        cliext::_XStable_sort(_First, _Last, _Count, _Tempbuf, _Pred);
        }
    }

template<class _BidIt,
    class _Pr> inline
    void stable_sort(_BidIt _First, _BidIt _Last, _Pr _Pred)
    {   // sort preserving order of equivalents, using _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    cliext::stable_sort_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Pred);
    }

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

_OutIt _Set_symmetric_difference_no_deprecate ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred  )

inline

    {   // test if all [_First1, _Last1) in [_First2, _Last2), using operator<
    for (; _First1 != _Last1 && _First2 != _Last2; )
        if (_STLCLRDB_LT(*_First2, *_First1))
            return (false);
        else if (*_First1 < *_First2)

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

_OutIt _Set_symmetric_difference_no_deprecate1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred  )

inline

    {   // order Nth element, using _Pred
    for (; _ISort::_Max < _Last - _First; )
        {   // divide and conquer, ordering partition containing Nth
        _PAIR_TYPE(_RanIt) _Mid =
            cliext::_XUnguarded_partition(_First, _Last, _Pred);

        if (_Mid.second <= _Nth)
            _First = _Mid.second;
        else if (_Mid.first <= _Nth)
            return; // Nth inside fat pivot, done
        else
            _Last = _Mid.first;
        }

    cliext::_XInsertion_sort(_First, _Last, _Pred); // sort any remainder
    }

template<class _RanIt,
    class _Pr> inline
    void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred)
    {   // order Nth element, using _Pred

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

_OutIt _Set_union_no_deprecate ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred  )

inline

            {   // temp buffer big enough, sort each half using buffer
            cliext::_XBuffered_merge_sort(_First, _Mid, _Count2,
                _Tempbuf, _Pred);
            cliext::_XBuffered_merge_sort(_Mid, _Last, _Count - _Count2,
                _Tempbuf, _Pred);
            }
        else

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

_OutIt _Set_union_no_deprecate1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr &  _Pred  )

inline

        {   // merge adjacent pairs of chunks to and from temp buffer
        cliext::_XChunked_merge(_First, _Last, _Tempbuf._Init(),
            _Chunk, _Count, _Pred);
        cliext::_XChunked_merge(_Tempbuf._First(), _Tempbuf._Last(), _First,
            _Chunk *= 2, _Count, _Pred);
        }
    }
#endif  // __cplusplus_cli

template<class _BidIt,
    class _Diff,
    class _Ty,
    class _Pr> inline
    void _XStable_sort(_BidIt _First, _BidIt _Last, _Diff _Count,
        _Temp_iterator<_Ty> _Tempbuf, _Pr _Pred)
    {   // sort preserving order of equivalents, using _Pred

template<class _RanIt , class _Pr >

void _Sort_heap_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr &  _Pred  )

inline

    {   // rotate [_First, _Last) using temp buffer
    if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())
        {   // buffer left partition, then copy parts
        cliext::copy_unchecked(_First, _Mid, _Tempbuf._Init());

template<class _RanIt , class _Pr >

void _Sort_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr &  _Pred  )

inline

            {   // no room at top, rotate pivot downward

template<class _RanIt , class _Diff , class _Pr >

void _Sort_unchecked1 ( _RanIt  _First, _RanIt  _Last, _Diff  _Ideal, _Pr &  _Pred  )

inline

        {   // partition
        for (; _Gfirst < _Last; ++_Gfirst)
            if (_STLCLRDB_LT_PRED(_Pred, *_Pfirst, *_Gfirst))
                ;
            else if (_Pred(*_Gfirst, *_Pfirst))
                break;
            else
                cliext::iter_swap(_Plast++, _Gfirst);
        for (; _First < _Glast; --_Glast)
            if (_STLCLRDB_LT_PRED(_Pred, *(_Glast - 1), *_Pfirst))
                ;
            else if (_Pred(*_Pfirst, *(_Glast - 1)))
                break;
            else
                cliext::iter_swap(--_Pfirst, _Glast - 1);
        if (_Glast == _First && _Gfirst == _Last)
            return (_PAIR_TYPE(_RanIt)(_Pfirst, _Plast));

template<class _BidIt , class _Pr >

_BidIt _Stable_partition_unchecked ( _BidIt  _First, _BidIt  _Last, _Pr &  _Pred  )

inline

        {   // divide and conquer, check midpoint
        _Diff _Count2 = _Count / 2;

template<class _BidIt , class _Pr , class _Diff , class _Ty >

_BidIt _Stable_partition_unchecked1 ( _BidIt  _First, _BidIt  _Last, _Pr &  _Pred, _Diff  _Count, _Temp_iterator< _Ty > &  _Tempbuf  )

inline

    {   // find first element that _Val is before, using _Pred
    typedef iterator_traits<_FwdIt>::difference_type _Diff;

    _Diff _Count = 0;
    _Iter_distance(_First, _Last, _Count);
    for (; 0 < _Count; )
        {   // divide and conquer, find half that contains answer
        _Diff _Count2 = _Count / 2;
        _FwdIt _Mid = _First;
        cliext::advance(_Mid, _Count2);

        if (!_STLCLRDB_LT_PRED(_Pred, _Val, *_Mid))
            _First = ++_Mid, _Count -= _Count2 + 1;
        else
            _Count = _Count2;
        }
    return (_First);
    }

template<class _FwdIt,
    class _Ty,
    class _Pr> inline
    _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred)
    {   // find first element that _Val is before, using _Pred
    _STLCLRDB_ORDER_PRED(_First, _Last, _Pred);
    return (cliext::upper_bound_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Val, _Pred));
    }

        // TEMPLATE FUNCTION equal_range
template<class _FwdIt,
    class _Ty> inline

template<class _BidIt , class _Pr >

void _Stable_sort_unchecked ( _BidIt  _First, _BidIt  _Last, _Pr &  _Pred  )

inline

        {   // merge adjacent pairs of chunks to and from temp buffer
        cliext::_XChunked_merge(_First, _Last, _Tempbuf._Init(),
            _Chunk, _Count);
        cliext::_XChunked_merge(_Tempbuf._First(), _Tempbuf._Last(), _First,
            _Chunk *= 2, _Count);
        }
    }

template<class _BidIt , class _Diff , class _Ty , class _Pr >

void _Stable_sort_unchecked1 ( _BidIt  _First, _BidIt  _Last, _Diff  _Count, _Temp_iterator< _Ty > &  _Tempbuf, _Pr &  _Pred  )

inline

        {   // copy merging whole and partial last chunk
        _BidIt _Mid = _First;
        cliext::advance(_Mid, _Chunk);

        cliext::merge_unchecked(_First, _Mid, _Mid, _Last, _Dest);
        }
    }

template<class _BidIt,
    class _Diff,
    class _Ty> inline
    void _XBuffered_merge_sort(_BidIt _First, _BidIt _Last, _Diff _Count,
        _Temp_iterator<_Ty> _Tempbuf)
    {   // sort using temp buffer for merges, using operator<
    _BidIt _Mid = _First;
    for (_Diff _Nleft = _Count; _ISort::_Max <= _Nleft; _Nleft -= _ISort::_Max)
        {   // sort chunks
        _BidIt _Midend = _Mid;
        cliext::advance(_Midend, (int)_ISort::_Max);

        cliext::_XInsertion_sort(_Mid, _Midend);

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt2 _Swap_ranges1 ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _Dest, forward_iterator_tag  , forward_iterator_tag    )

inline

    {   // remove each satisfying _Pred

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt2 _Swap_ranges1 ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _Dest, random_access_iterator_tag  , random_access_iterator_tag    )

inline

    {   // remove each satisfying _Pred
    _First = cliext::find_if_unchecked(_First, _Last, _Pred);
    if (_First == _Last)
        return (_First);    // empty sequence, all done
    else
        {   // nonempty sequence, worth doing
        _FwdIt _First1 = _First;
        return (cliext::remove_copy_if_unchecked(++_First1, _Last,

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt2 _Swap_ranges_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _Dest  )

inline

        {   // nonempty sequence, worth doing
        _FwdIt _First1 = _First;
        return (cliext::remove_copy(++_First1, _Last, _First, _Val));
        }
    }

template<class _FwdIt,

template<class _InIt , class _OutIt , class _Fn1 >

_OutIt _Transform_no_deprecate ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Fn1 &  _Func  )

inline

    {   // copy compressing pairs that match, input iterators
    typedef iterator_traits<_InIt>::value_type _Ty;

template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >

_OutIt _Transform_no_deprecate ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _OutIt  _Dest, _Fn2 &  _Func  )

inline

    {   // copy compressing pairs satisfying _Pred, random-access iterators
    return (_Unique_copy(_First, _Last, _Dest, _Pred,
        forward_iterator_tag()));

template<class _InIt , class _OutIt , class _Fn1 >

_OutIt _Transform_no_deprecate1 ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Fn1 &  _Func, input_iterator_tag  , _Any_tag    )

inline

    {   // remove each satisfying _Pred with previous
    for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
        if (_Pred(*_Firstb, *_First))
            {   // copy down
            for (; ++_First != _Last; )
                if (!_Pred(*_Firstb, *_First))

template<class _InIt , class _OutIt , class _Fn1 >

_OutIt _Transform_no_deprecate1 ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Fn1 &  _Func, random_access_iterator_tag  , random_access_iterator_tag    )

inline

    {   // remove each satisfying _Pred with previous
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);

template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >

_OutIt _Transform_no_deprecate1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _OutIt  _Dest, _Fn2 &  _Func, input_iterator_tag  , input_iterator_tag    )

inline

    {   // copy compressing pairs satisfying _Pred, forward iterators

template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >

_OutIt _Transform_no_deprecate1 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _OutIt  _Dest, _Fn2 &  _Func, random_access_iterator_tag  , random_access_iterator_tag    )

inline

    {   // copy compressing pairs satisfying _Pred, bidirectional iterators

template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >

_OutIt _Transform_no_deprecate2 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _OutIt  _Dest, _Fn2 &  _Func, input_iterator_tag  , _Any_tag    )

inline

    {   // copy compressing pairs that match
    _STLCLRDB_RANGE(_First, _Last);

template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >

_OutIt _Transform_no_deprecate2 ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _OutIt  _Dest, _Fn2 &  _Func, random_access_iterator_tag  , random_access_iterator_tag    )

inline

    {   // copy compressing pairs satisfying _Pred, input iterators

template<class _InIt , class _OutIt , class _Fn1 >

_OutIt _Transform_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Fn1 &  _Func  )

inline

    {   // remove each matching previous
    _STLCLRDB_RANGE(_First, _Last);
    return (cliext::unique_unchecked(
        _Unchecked(_First), _Unchecked(_Last)));
    }

template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >

_OutIt _Transform_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _OutIt  _Dest, _Fn2 &  _Func  )

inline

    {   // copy compressing pairs that match, random-access iterators
    return (_Unique_copy(_First, _Last, _Dest, forward_iterator_tag()));
    }

template<class _InIt,

template<class _InIt , class _OutIt , class _Pr >

_OutIt _Unique_copy_no_deprecate ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred  )

inline

        {   // check and push non-empty heap+addition
        _STLCLRDB_HEAP_PRED(_First, _Last - 1, _Pred);
        cliext::push_heap_unchecked(_Unchecked(_First), _Unchecked(_Last),
            _Pred);
        }
    }

template<class _InIt , class _OutIt , class _Pr >

_OutIt _Unique_copy_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred, input_iterator_tag    )

inline

    {   // percolate _Hole to _Top or where _Val belongs, using operator<
    for (_Diff _Idx = (_Hole - 1) / 2;
        _Top < _Hole && _STLCLRDB_LT_PRED(_Pred, *(_First + _Idx), _Val);
        _Idx = (_Hole - 1) / 2)
        {   // move _Hole up to parent
        *(_First + _Hole) = *(_First + _Idx);
        _Hole = _Idx;
        }

template<class _FwdIt , class _OutIt , class _Pr >

_OutIt _Unique_copy_unchecked ( _FwdIt  _First, _FwdIt  _Last, _OutIt  _Dest, _Pr &  _Pred, forward_iterator_tag    )

inline

    {   // push *(_Last - 1) onto heap at [_First, _Last - 1), using _Pred
    typedef iterator_traits<_RanIt>::difference_type _Diff;
    typedef iterator_traits<_RanIt>::value_type _Ty;

    --_Last;
    _Diff _Count = _Last - _First;
    if (0 < _Count)
        cliext::_XPush_heap(_First, _Count, _Diff(0), _Ty(*_Last), _Pred);
    }

template<class _RanIt,
    class _Pr> inline
    void push_heap(_RanIt _First, _RanIt _Last, _Pr _Pred)
    {   // push *(_Last - 1) onto heap at [_First, _Last - 1), using _Pred

template<class _FwdIt , class _Pr >

_FwdIt _Unique_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr &  _Pred  )

inline

    {   // percolate _Hole to _Top or where _Val belongs, using operator<
    for (_Diff _Idx = (_Hole - 1) / 2;
        _Top < _Hole && _STLCLRDB_LT(*(_First + _Idx), _Val);
        _Idx = (_Hole - 1) / 2)
        {   // move _Hole up to parent
        *(_First + _Hole) = *(_First + _Idx);
        _Hole = _Idx;
        }

    *(_First + _Hole) = _Val;   // drop _Val into final hole
    }

template<class _RanIt> inline
    void push_heap_unchecked(_RanIt _First, _RanIt _Last)

template<class _FwdIt , class _Ty , class _Pr >

_FwdIt _Upper_bound_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr &  _Pred  )

inline

    {   // merge [_First, _Mid) with [_Mid, _Last), using operator<
    if (_Count1 + _Count2 == 2)
        {   // order two one-element partitions
        if (_STLCLRDB_LT(*_Mid, *_First))
            cliext::iter_swap(_First, _Mid);
        }
    else if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())
        {   // buffer left partition, then merge
        cliext::copy_unchecked(_First, _Mid, _Tempbuf._Init());
        cliext::merge_unchecked(_Tempbuf._First(), _Tempbuf._Last(),
            _Mid, _Last, _First);
        }
    else if (_Count2 <= _Tempbuf._Maxlen())
        {   // buffer right partition, then merge
        cliext::copy_unchecked(_Mid, _Last, _Tempbuf._Init());
        cliext::_XMerge_backward(_First, _Mid,
            _Tempbuf._First(), _Tempbuf._Last(), _Last);
        }

template<class _FwdIt , class _Pr >

_FwdIt adjacent_find ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

    {   // find first matching successor
    _STLCLRDB_RANGE(_First, _Last);
    return (cliext::adjacent_find_unchecked(
        _Unchecked(_First), _Unchecked(_Last)));
    }

        // TEMPLATE FUNCTION adjacent_find WITH PRED

template<class _FwdIt >

_FwdIt adjacent_find ( _FwdIt  _First, _FwdIt  _Last  )

inline

    {   // find first satisfying _Pred with successor
    for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
        if (_Pred(*_Firstb, *_First))
            return (_Firstb);

template<class _InIt , class _Pr >

bool all_of ( _InIt  _First, _InIt  _Last, _Pr  _Pred  )

inline

            {   // no match, take big jump and back up as needed

template<class _InIt , class _Pr >

bool any_of ( _InIt  _First, _InIt  _Last, _Pr  _Pred  )

inline

    {   // find first _Count * _Val match

template<class _FwdIt , class _Ty , class _Pr >

bool binary_search ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr  _Pred  )

inline

        {   // merge nontrivial sequence
        _Diff _Count1 = 0;
        _Iter_distance(_First, _Mid, _Count1);

template<class _FwdIt , class _Ty >

bool binary_search ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val  )

inline

    {   // merge [_First, _Mid) with [_Mid, _Last), using operator<

template<class _InIt , class _OutIt , class _Pr >

_OutIt copy_if ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr  _Pred  )

inline

    {   // find first _Count * _Val satisfying _Pred

template<class _InIt , class _Pr >

iterator_traits<_InIt>::difference_type count_if ( _InIt  _First, _InIt  _Last, _Pr  _Pred  )

inline

    {   // count elements that match _Val
    typename iterator_traits<_InIt>::difference_type _Count = 0;

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

template<class _FwdIt , class _Ty , class _Pr >

pair<_FwdIt, _FwdIt> equal_range ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr  _Pred  )

inline

            {   // left larger, cut it in half and partition right to match
            _Count1n = _Count1 / 2, _Count2n = 0;
            _Firstn = _First;
            cliext::advance(_Firstn, _Count1n);

template<class _FwdIt , class _Ty >

pair<_FwdIt, _FwdIt> equal_range ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val  )

inline

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

_FwdIt1 find_end ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr  _Pred  )

inline

    {   // copy omitting each matching _Val
    for (; _First != _Last; ++_First)
        if (!(*_First == _Val))
            *_Dest++ = *_First;
    return (_Dest);

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt1 find_end ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2  )

inline

    {   // copy omitting each matching _Val
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

_FwdIt1 find_first_of ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr  _Pred  )

inline

    {   // copy omitting each element satisfying _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::remove_copy_if_unchecked(

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt1 find_first_of ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2  )

inline

    {   // remove each matching _Val

template<class _InIt , class _Pr >

_InIt find_if ( _InIt  _First, _InIt  _Last, _Pr  _Pred  )

inline

    {   // find first satisfying _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::find_if_unchecked(

template<class _InIt , class _Pr >

_InIt find_if_not ( _InIt  _First, _InIt  _Last, _Pr  _Pred  )

inline

    {   // find first _Count * _Val satisfying _Pred, random-access iterators

template<class _InIt , class _Fn1 >

_Fn1 for_each ( _InIt  _First, _InIt  _Last, _Fn1  _Func  )

inline

    {   // find first unsigned char that matches _Val
    _STLCLRDB_RANGE(_First, _Last);
    _First = (const unsigned char *)std::memchr(_First, _Val,
        _Last - _First);
    return (_First == 0 ? _Last : _First);
    }

template<class _FwdIt , class _Fn0 >

void generate ( _FwdIt  _First, _FwdIt  _Last, _Fn0  _Func  )

inline

template<class _OutIt , class _Diff , class _Fn0 >

_OutIt generate_n ( _OutIt  _Dest, _Diff  _Count, _Fn0  _Func  )

inline

    {   // partition preserving order of equivalents, using _Pred

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

        {   // merge adjacent pairs of chunks to and from temp buffer
        cliext::_XChunked_merge(_First, _Last, _Tempbuf._Init(),
            _Chunk, _Count, _Pred);
        cliext::_XChunked_merge(_Tempbuf._First(), _Tempbuf._Last(), _First,
            _Chunk *= 2, _Count, _Pred);

template<class _InIt1 , class _InIt2 >

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

inline

    {   // sort using temp buffer for merges, using _Pred

template<class _BidIt , class _Pr >

void inplace_merge ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last, _Pr  _Pred  )

inline

            {   // no room at bottom, rotate pivot upward
            if (_Plast != _Gfirst)
                cliext::iter_swap(_Pfirst, _Plast);
            ++_Plast;

template<class _BidIt >

void inplace_merge ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last  )

inline

            {   // no room at top, rotate pivot downward
            if (--_Glast != --_Pfirst)
                cliext::iter_swap(_Glast, _Pfirst);
            cliext::iter_swap(_Pfirst, --_Plast);

template<class _RanIt , class _Pr >

bool is_heap ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

            {   // swap with rightmost element that's smaller, flip suffix
            _BidIt _Mid = _Last;
            for (; !_STLCLRDB_LT(*_Next, *--_Mid); )
                ;

template<class _RanIt >

bool is_heap ( _RanIt  _First, _RanIt  _Last  )

inline

    {   // permute and test for pure ascending, using operator<

template<class _RanIt , class _Pr >

_RanIt is_heap_until ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

    {   // permute and test for pure ascending, using operator<
    _BidIt _Next = _Last;
    if (_First == _Last || _First == --_Next)
        return (false);

template<class _RanIt >

_RanIt is_heap_until ( _RanIt  _First, _RanIt  _Last  )

inline

            {   // pure descending, flip all

template<class _InIt , class _Pr >

bool is_partitioned ( _InIt  _First, _InIt  _Last, _Pr  _Pred  )

inline

    {   // look for one of [_First2, _Last2) satisfying _Pred with element
    for (; _First1 != _Last1; ++_First1)
        for (_FwdIt2 _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2)
            if (_Pred(*_First1, *_Mid2))
                return (_First1);

template<class _FwdIt , class _Pr >

bool is_sorted ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

            {   // pure descending, flip all

template<class _FwdIt >

bool is_sorted ( _FwdIt  _First, _FwdIt  _Last  )

inline

    {   // permute and test for pure ascending, using _Pred

template<class _FwdIt , class _Pr >

_FwdIt is_sorted_until ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

        {   // find rightmost element smaller than successor
        _BidIt _Next1 = _Next;
        if (_STLCLRDB_LT_PRED(_Pred, *--_Next, *_Next1))

template<class _FwdIt >

_FwdIt is_sorted_until ( _FwdIt  _First, _FwdIt  _Last  )

inline

    {   // permute and test for pure ascending, using _Pred

template<class _FwdIt , class _Ty , class _Pr >

_FwdIt lower_bound ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr  _Pred  )

inline

    {   // merge backwards to _Dest, using operator<

template<class _FwdIt , class _Ty >

_FwdIt lower_bound ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val  )

inline

    {   // merge [_First, _Mid) with [_Mid, _Last), using operator<

template<class _RanIt , class _Pr >

void make_heap ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

    {   //  copy merging ranges, both using _Pred
    _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
    _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
    _STLCLRDB_POINTER(_Dest);

template<class _RanIt >

void make_heap ( _RanIt  _First, _RanIt  _Last  )

inline

    {   // rotate [_First, _Last) using temp buffer

template<class _Ty , class _Pr >

constexpr const _Ty&() max ( const _Ty &  _Left, const _Ty &  _Right, _Pr  _Pred  )

inline

template<class _Ty , class _Pr >

_Ty() max ( _XSTD initializer_list< _Ty >  _Ilist, _Pr  _Pred  )

inline

    {   // take set [_First2, _Last2) from [_First1, _Last1), using operator<

template<class _Ty >

_Ty() max ( _XSTD initializer_list< _Ty >  _Ilist )

inline

    {   //  take set [_First2, _Last2) from [_First1, _Last1), using _Pred

template<class _FwdIt , class _Pr >

_FwdIt max_element ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

    {   // OR sets [_First1, _Last1) and [_First2, _Last2), using _Pred

template<class _FwdIt >

_FwdIt max_element ( _FwdIt  _First, _FwdIt  _Last  )

inline

    {   // OR sets [_First1, _Last1) and [_First2, _Last2), using _Pred

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

_OutIt merge ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr  _Pred  )

inline

    {   // merge [_First, _Mid) with [_Mid, _Last), using _Pred

template<class _InIt1 , class _InIt2 , class _OutIt >

_OutIt merge ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest  )

inline

        {   // buffer too small, divide and conquer
        _BidIt _Firstn, _Lastn;

template<class _Ty , class _Pr >

constexpr const _Ty&() min ( const _Ty &  _Left, const _Ty &  _Right, _Pr  _Pred  )

inline

template<class _Ty , class _Pr >

_Ty() min ( _XSTD initializer_list< _Ty >  _Ilist, _Pr  _Pred  )

inline

    {   //  take set [_First2, _Last2) from [_First1, _Last1), using _Pred

template<class _Ty >

_Ty() min ( _XSTD initializer_list< _Ty >  _Ilist )

inline

    {   // XOR sets [_First1, _Last1) and [_First2, _Last2), using operator<

template<class _FwdIt , class _Pr >

_FwdIt min_element ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

    {   // OR sets [_First1, _Last1) and [_First2, _Last2), using _Pred
    _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);

template<class _FwdIt >

_FwdIt min_element ( _FwdIt  _First, _FwdIt  _Last  )

inline

    {   // AND sets [_First1, _Last1) and [_First2, _Last2), using operator<

template<class _Ty , class _Pr >

constexpr pair<const _Ty&, const _Ty&> minmax ( const _Ty &  _Left, const _Ty &  _Right, _Pr  _Pred  )

inline

    {   // XOR sets [_First1, _Last1) and [_First2, _Last2), using operator<

template<class _Ty , class _Pr >

pair<_Ty, _Ty> minmax ( _XSTD initializer_list< _Ty >  _Ilist, _Pr  _Pred  )

inline

    {   // XOR sets [_First1, _Last1) and [_First2, _Last2), using operator<
    _STLCLRDB_ORDER(_First1, _Last1);
    _STLCLRDB_ORDER(_First2, _Last2);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::set_symmetric_difference_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),

template<class _Ty >

constexpr pair<const _Ty&, const _Ty&> minmax ( const _Ty &  _Left, const _Ty &  _Right  )

inline

    {   // XOR sets [_First1, _Last1) and [_First2, _Last2), using _Pred

template<class _Ty >

pair<_Ty, _Ty> minmax ( _XSTD initializer_list< _Ty >  _Ilist )

inline

template<class _FwdIt , class _Pr >

pair<_FwdIt, _FwdIt> minmax_element ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

    {   // AND sets [_First1, _Last1) and [_First2, _Last2), using _Pred

template<class _FwdIt >

pair<_FwdIt, _FwdIt> minmax_element ( _FwdIt  _First, _FwdIt  _Last  )

inline

    {   // take set [_First2, _Last2) from [_First1, _Last1), using operator<

template<class _InIt1 , class _InIt2 , class _Pr >

pair<_InIt1, _InIt2> mismatch ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr  _Pred  )

inline

    {   // find first [_First2, _Last2) match

template<class _InIt1 , class _InIt2 >

pair<_InIt1, _InIt2> mismatch ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2  )

inline

        {   // room for match, try it

template<class _InIt1 , class _InIt2 , class _Pr >

pair<_InIt1, _InIt2> mismatch ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr  _Pred  )

inline

            {   // found start of possible match, check it out
            _FwdIt1 _Mid1  = _First1;

            for (_Diff2 _Count1 = _Count; ; )
                if (--_Count1 == 0)
                    return (_First1);   // found rest of match, report it
                else if (++_Mid1 == _Last1)
                    return (_Last1);    // short match at end

template<class _InIt1 , class _InIt2 >

pair<_InIt1, _InIt2> mismatch ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2  )

inline

    {   // find first _Count * _Val match, random-access iterators

template<class _BidIt , class _Pr >

bool next_permutation ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred  )

inline

    {   // find largest element, using operator<
    _STLCLRDB_RANGE(_First, _Last);
    return (cliext::max_element_unchecked(
        _Unchecked(_First), _Unchecked(_Last)));

template<class _BidIt >

bool next_permutation ( _BidIt  _First, _BidIt  _Last  )

inline

    {   // find largest element, using _Pred

template<class _InIt , class _Pr >

bool none_of ( _InIt  _First, _InIt  _Last, _Pr  _Pred  )

inline

    {   // find first _Count * _Val satisfying _Pred, forward iterators
    if (_Count <= 0)
        return (_First1);

template<class _RanIt , class _Pr >

void nth_element ( _RanIt  _First, _RanIt  _Nth, _RanIt  _Last, _Pr  _Pred  )

inline

        {   // copy merging pairs of adjacent chunks
        _BidIt _Mid1 = _First;
        cliext::advance(_Mid1, _Chunk);
        _BidIt _Mid2 = _Mid1;
        cliext::advance(_Mid2, _Chunk);

        _Dest = cliext::merge_unchecked(_First, _Mid1,
            _Mid1, _Mid2, _Dest, _Pred);

template<class _RanIt >

void nth_element ( _RanIt  _First, _RanIt  _Nth, _RanIt  _Last  )

inline

        {   // copy merging whole and partial last chunk

template<class _RanIt , class _Pr >

void partial_sort ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, _Pr  _Pred  )

inline

        {   // sort halves and merge
        _Diff _Count2 = (_Count + 1) / 2;
        _BidIt _Mid = _First;
        cliext::advance(_Mid, _Count2);

        if (_Count2 <= _Tempbuf._Maxlen())

template<class _RanIt >

void partial_sort ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last  )

inline

            {   // temp buffer not big enough, divide and conquer

template<class _InIt , class _RanIt , class _Pr >

_RanIt partial_sort_copy ( _InIt  _First1, _InIt  _Last1, _RanIt  _First2, _RanIt  _Last2, _Pr  _Pred  )

inline

            {   // temp buffer not big enough, divide and conquer
            cliext::_XStable_sort(_First, _Mid, _Count2, _Tempbuf);
            cliext::_XStable_sort(_Mid, _Last, _Count - _Count2, _Tempbuf);
            }

        cliext::_XBuffered_merge(_First, _Mid, _Last,

template<class _InIt , class _RanIt >

_RanIt partial_sort_copy ( _InIt  _First1, _InIt  _Last1, _RanIt  _First2, _RanIt  _Last2  )

inline

    {   // sort preserving order of equivalents, using operator<
    typedef iterator_traits<_BidIt>::difference_type _Diff;
    typedef iterator_traits<_BidIt>::value_type _Ty;

template<class _FwdIt , class _Pr >

_FwdIt partition ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

    {   // find first element not before _Val, using _Pred
    _STLCLRDB_ORDER_PRED(_First, _Last, _Pred);
    return (cliext::lower_bound_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Val, _Pred));
    }

template<class _InIt , class _OutIt1 , class _OutIt2 , class _Pr >

pair<_OutIt1, _OutIt2> partition_copy ( _InIt  _First, _InIt  _Last, _OutIt1  _Dest1, _OutIt2  _Dest2, _Pr  _Pred  )

inline

    {   // find last [_First2, _Last2) satisfying _Pred
    typedef iterator_traits<_FwdIt1>::difference_type _Diff1;
    typedef iterator_traits<_FwdIt2>::difference_type _Diff2;

template<class _FwdIt , class _Pr >

_FwdIt partition_point ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

    {   // swap [_First1, _Last1) with [_First2, ...)
    for (; _First1 != _Last1; ++_First1, ++_First2)
        cliext::iter_swap(_First1, _First2);

template<class _RanIt , class _Pr >

void pop_heap ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

    {   // copy merging ranges, both using operator<
    _STLCLRDB_ORDER(_First1, _Last1);
    _STLCLRDB_ORDER(_First2, _Last2);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::merge_unchecked(

template<class _RanIt >

void pop_heap ( _RanIt  _First, _RanIt  _Last  )

inline

    {   //  copy merging ranges, both using _Pred

template<class _BidIt , class _Pr >

bool prev_permutation ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred  )

inline

    {   // find smallest element, using _Pred

template<class _BidIt >

bool prev_permutation ( _BidIt  _First, _BidIt  _Last  )

inline

    {   // find smallest element, using _Pred
    _FwdIt _Found = _First;
    if (_First != _Last)

template<class _RanIt , class _Pr >

void push_heap ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

    {   // find range equivalent to _Val, using _Pred

template<class _RanIt >

void push_heap ( _RanIt  _First, _RanIt  _Last  )

inline

    {   // test if _Val equivalent to some element, using operator<

template<class _FwdIt , class _Ty >

_FwdIt remove ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val  )

inline

    {   // test if range is a heap ordered by _Pred

template<class _InIt , class _OutIt , class _Ty >

_OutIt remove_copy ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, const _Ty &  _Val  )

inline

    {   // partition preserving order of equivalents, using _Pred

template<class _InIt , class _OutIt , class _Pr >

_OutIt remove_copy_if ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr  _Pred  )

inline

    {   // partition preserving order of equivalents, using _Pred
    typedef iterator_traits<_BidIt>::difference_type _Diff;
    typedef iterator_traits<_BidIt>::value_type _Ty;

template<class _FwdIt , class _Pr >

_FwdIt remove_if ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

    {   // percolate _Hole to _Top or where _Val belongs, using operator<

template<class _FwdIt , class _Ty >

void replace ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Oldval, const _Ty &  _Newval  )

inline

    {   // rotate [_First, _Last), forward iterators

template<class _InIt , class _OutIt , class _Ty >

_OutIt replace_copy ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, const _Ty &  _Oldval, const _Ty &  _Newval  )

inline

    {   // rotate [_First, _Last)
    _STLCLRDB_RANGE(_First, _Mid);
    _STLCLRDB_RANGE(_Mid, _Last);
    if (_First != _Mid && _Mid != _Last)

template<class _InIt , class _OutIt , class _Pr , class _Ty >

_OutIt replace_copy_if ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr  _Pred, const _Ty &  _Val  )

inline

    {   // shuffle [_First, _Last) using random function _Func
    typedef iterator_traits<_RanIt>::difference_type _Diff;

template<class _FwdIt , class _Pr , class _Ty >

void replace_if ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred, const _Ty &  _Val  )

inline

    {   // rotate [_First, _Last), bidirectional iterators
    cliext::reverse(_First, _Mid);
    cliext::reverse(_Mid, _Last);

template<class _BidIt , class _OutIt >

_OutIt reverse_copy ( _BidIt  _First, _BidIt  _Last, _OutIt  _Dest  )

inline

    {   // pop *_First to *_Dest and reheap, using _Pred
    typedef iterator_traits<_RanIt>::difference_type _Diff;

template<class _FwdIt , class _OutIt >

_OutIt rotate_copy ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last, _OutIt  _Dest  )

inline

    {   // make [_First, _Last) into a heap, using operator<
    _STLCLRDB_RANGE(_First, _Last);
    cliext::make_heap_unchecked(_Unchecked(_First), _Unchecked(_Last));
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

_FwdIt1 search ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr  _Pred  )

inline

    {   // transform [_First1, _Last1) and [_First2, _Last2) with _Func

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt1 search ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2  )

inline

    {   // replace each matching _Oldval with _Newval

template<class _FwdIt , class _Diff , class _Ty , class _Pr >

_FwdIt search_n ( _FwdIt  _First, _FwdIt  _Last, _Diff  _Count, const _Ty &  _Val, _Pr  _Pred  )

inline

    {   // copy replacing each satisfying _Pred with _Val
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);

template<class _FwdIt , class _Diff , class _Ty >

_FwdIt search_n ( _FwdIt  _First, _FwdIt  _Last, _Diff  _Count, const _Ty &  _Val  )

inline

    {   // replace [_First, _Last) with _Func()

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

_OutIt set_difference ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr  _Pred  )

inline

template<class _InIt1 , class _InIt2 , class _OutIt >

_OutIt set_difference ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest  )

inline

    {   // order Nth element, using operator<
    for (; _ISort::_Max < _Last - _First; )
        {   // divide and conquer, ordering partition containing Nth
        _PAIR_TYPE(_RanIt) _Mid =
            cliext::_XUnguarded_partition(_First, _Last);

        if (_Mid.second <= _Nth)

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

_OutIt set_intersection ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr  _Pred  )

inline

    {   // order [First, _Last) up to _Mid, using _Pred

template<class _InIt1 , class _InIt2 , class _OutIt >

_OutIt set_intersection ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest  )

inline

    {   // copy [First1, _Last1) into [_First2, _Last2), using operator<

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

_OutIt set_symmetric_difference ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr  _Pred  )

inline

    {   // test if all [_First1, _Last1) in [_First2, _Last2), using operator<
    _STLCLRDB_ORDER(_First1, _Last1);
    _STLCLRDB_ORDER(_First2, _Last2);

template<class _InIt1 , class _InIt2 , class _OutIt >

_OutIt set_symmetric_difference ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest  )

inline

    {   // test if set [_First1, _Last1) in [_First2, _Last2), using _Pred
    _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);

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

_OutIt set_union ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr  _Pred  )

inline

    {   // sort preserving order of equivalents, using _Pred

template<class _InIt1 , class _InIt2 , class _OutIt >

_OutIt set_union ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest  )

inline

            {   // temp buffer not big enough, divide and conquer
            cliext::_XStable_sort(_First, _Mid, _Count2, _Tempbuf,

template<class _RanIt , class _Urng >

void shuffle ( _RanIt  _First, _RanIt  _Last, _Urng &&  _Func  )

inline

    {   // order heap by repeatedly popping, using operator<
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_HEAP(_First, _Last);
    cliext::sort_heap_unchecked(_Unchecked(_First), _Unchecked(_Last));
    }

template<class _RanIt , class _Pr >

void sort ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

    {   // order [_First, _Last), using _Pred

template<class _RanIt >

void sort ( _RanIt  _First, _RanIt  _Last  )

inline

    {   // order [_First, _Last), using _Pred

template<class _RanIt , class _Pr >

void sort_heap ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

        {   // buffer right partition, then copy parts
        cliext::copy_unchecked(_Mid, _Last, _Tempbuf._Init());
        cliext::copy_backward_unchecked(_First, _Mid, _Last);
        return (cliext::copy_unchecked(
            _Tempbuf._First(), _Tempbuf._Last(), _First));

template<class _RanIt >

void sort_heap ( _RanIt  _First, _RanIt  _Last  )

inline

    {   // rotate [_First, _Last) using temp buffer

template<class _BidIt , class _Pr >

_BidIt stable_partition ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred  )

inline

            {   // range begins above _Mid, loop
            _First = ++_Mid;
            _Count -= _Count2 + 1;
            }
        else if (_Val < *_Mid)

template<class _BidIt , class _Pr >

void stable_sort ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred  )

inline

    {   // sort using temp buffer for merges, using operator<

template<class _BidIt >

void stable_sort ( _BidIt  _First, _BidIt  _Last  )

inline

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt2 swap_ranges ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _Dest  )

inline

    {   // remove each satisfying _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::remove_if_unchecked(

template<class _InIt , class _OutIt , class _Fn1 >

_OutIt transform ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Fn1  _Func  )

inline

    {   // copy compressing pairs that match, forward iterators

template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >

_OutIt transform ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _OutIt  _Dest, _Fn2  _Func  )

inline

    {   // copy compressing pairs satisfying _Pred
    return (_First == _Last ? _Dest
        : _Unique_copy(_First, _Last, _Dest, _Pred, _Iter_category(_First)));
    }

template<class _InIt,

template<class _FwdIt , class _Pr >

_FwdIt unique ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

    {   // push *(_Last - 1) onto heap at [_First, _Last - 1), using operator<

template<class _FwdIt >

_FwdIt unique ( _FwdIt  _First, _FwdIt  _Last  )

inline

        {   // check and push non-empty heap+addition

template<class _InIt , class _OutIt , class _Pr >

_OutIt unique_copy ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr  _Pred  )

inline

    {   // percolate _Hole to _Bottom, then push _Val, using operator<
    _Diff _Top = _Hole;
    _Diff _Idx = 2 * _Hole + 2;

    for (; _Idx < _Bottom; _Idx = 2 * _Idx + 2)

template<class _InIt , class _OutIt >

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

inline

    {   // pop *_First to *_Dest and reheap, using operator<
    typedef iterator_traits<_RanIt>::difference_type _Diff;

    *_Dest = *_First;
    cliext::_XAdjust_heap(_First, _Diff(0), _Diff(_Last - _First), _Val);

template<class _FwdIt , class _Ty , class _Pr >

_FwdIt upper_bound ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr  _Pred  )

inline

            {   // left larger, cut it in half and partition right to match
            _Count1n = _Count1 / 2, _Count2n = 0;
            _Firstn = _First;
            cliext::advance(_Firstn, _Count1n);
            _Lastn = cliext::lower_bound_unchecked(_Mid, _Last, *_Firstn);

template<class _FwdIt , class _Ty >

_FwdIt upper_bound ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val  )

inline

Variable Documentation

_STD_BEGIN const int _ISORT_MAX = 32

constexpr const _Ty&() _Left

constexpr const _Ty&() _Left

Initial value:

{   
    return (_DEBUG_LT_PRED(_Pred, _Right, _Left) ? _Right : _Left)

const _Ty & _Right

Initial value:

{   
    return (_DEBUG_LT_PRED(_Pred, _Left, _Right) ? _Right : _Left)

constexpr const _Ty&() _Right