algorithm File Reference

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

Classes
struct	_Temporary_buffer< _Ty >
struct	_Temporary_range< _Ty >
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 >
_CONSTEXPR14 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 >
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_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_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_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_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_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 _FwdIt , class _OutIt , class _Pr >
_OutIt	_Unique_copy_unchecked (_FwdIt _First, _FwdIt _Last, _OutIt _Dest, _Pr &_Pred, true_type, _Any_tag)
template<class _InIt , class _FwdIt , class _Pr >
_FwdIt	_Unique_copy_unchecked (_InIt _First, _InIt _Last, _FwdIt _Dest, _Pr &_Pred, false_type, true_type)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	_Unique_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr &_Pred, false_type, false_type)
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_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_copy (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
template<class _RanIt , class _RngFn >
void	_Random_shuffle_unchecked (_RanIt _First, _RanIt _Last, _RngFn &_RngFunc)
template<class _RanIt , class _RngFn >
void	_Random_shuffle1 (_RanIt _First, _RanIt _Last, _RngFn &_RngFunc)
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 (const _BidIt _First, const _BidIt _Mid, const _BidIt _Last, const _Diff _Count1, const _Diff _Count2, _Temporary_buffer< _Ty > &_Temp_buf)
template<class _BidIt , class _Pr , class _Diff , class _Ty >
pair< _BidIt, _Diff >	_Stable_partition_unchecked1 (_BidIt _First, _BidIt _Last, _Pr &_Pred, const _Diff _Count, _Temporary_buffer< _Ty > &_Temp_buf)
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)
_Distance_unknown	_Idl_dist_add (_Distance_unknown, _Distance_unknown)
template<class _Diff1 >
_Distance_unknown	_Idl_dist_add (_Diff1, _Distance_unknown)
template<class _Diff2 >
_Distance_unknown	_Idl_dist_add (_Distance_unknown, _Diff2)
template<class _Diff1 , class _Diff2 >
auto	_Idl_dist_add (_Diff1 _Lhs, _Diff2 _Rhs)
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, _Temporary_buffer< _Ty > &_Temp_buf, _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, _Temporary_buffer< _Ty > &_Temp_buf, _Pr &_Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	_Stable_sort_unchecked1 (_BidIt _First, _BidIt _Last, _Diff _Count, _Temporary_buffer< _Ty > &_Temp_buf, _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 >
_CONSTEXPR14 _FwdIt	_Max_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
_CONSTEXPR14 _FwdIt	max_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_CONSTEXPR14 _FwdIt	max_element (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_CONSTEXPR14 _FwdIt	_Min_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
_CONSTEXPR14 _FwdIt	min_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_CONSTEXPR14 _FwdIt	min_element (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_CONSTEXPR14 pair< _FwdIt, _FwdIt >	_Minmax_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr &_Pred)
template<class _FwdIt , class _Pr >
_CONSTEXPR14 pair< _FwdIt, _FwdIt >	minmax_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_CONSTEXPR14 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 >
_CONSTEXPR14 _Ty()	max (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 >
_CONSTEXPR14 _Ty()	max (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 >
_CONSTEXPR14 _Ty()	min (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 >
_CONSTEXPR14 _Ty()	min (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 >
_CONSTEXPR14 pair< _Ty, _Ty >	minmax (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 >
_CONSTEXPR14 pair< _Ty, _Ty >	minmax (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

    {   // count elements satisfying _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::count_if_unchecked(_Unchecked(_First), _Unchecked(_Last),
        _Pred));
    }

template<class _InIt , class _Pr >

bool _All_of_unchecked ( _InIt  _First, _InIt  _Last, _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)

template<class _InIt , class _Pr >

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

inline

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

template<class _FwdIt , class _Ty , class _Pr >

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

inline

        {   // buffer right partition, then merge
        cliext::copy_unchecked(_Mid, _Last, _Tempbuf._Init());
        cliext::_XMerge_backward(_First, _Mid,
            _Tempbuf._First(), _Tempbuf._Last(), _Last, _Pred);
        }

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

            {   // no room at bottom, rotate pivot upward
            if (_Plast != _Gfirst)
                cliext::iter_swap(_Pfirst, _Plast);
            ++_Plast;
            cliext::iter_swap(_Pfirst++, _Gfirst++);
            }
        else if (_Gfirst == _Last)
            {   // no room at top, rotate pivot downward
            if (--_Glast != --_Pfirst)
                cliext::iter_swap(_Glast, _Pfirst);
            cliext::iter_swap(_Pfirst, --_Plast);
            }
        else
            cliext::iter_swap(_Gfirst++, --_Glast);
        }
    }

template<class _RanIt,
    class _Diff> inline
    void _XSort(_RanIt _First, _RanIt _Last, _Diff _Ideal)
    {   // order [_First, _Last), using operator<
    _Diff _Count;
    for (; _ISort::_Max < (_Count = _Last - _First) && 0 < _Ideal; )
        {   // divide and conquer by quicksort
        _PAIR_TYPE(_RanIt) _Mid =

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

void _Buffered_merge_sort_unchecked ( _BidIt  _First, _BidIt  _Last, _Diff  _Count, _Temporary_buffer< _Ty > &  _Temp_buf, _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);

        if (_Count2 <= _Tempbuf._Maxlen())
            {   // temp buffer big enough, sort each half using buffer
            cliext::_XBuffered_merge_sort(_First, _Mid, _Count2,
                _Tempbuf);
            cliext::_XBuffered_merge_sort(_Mid, _Last, _Count - _Count2,
                _Tempbuf);
            }
        else
            {   // temp buffer not big enough, divide and conquer
            cliext::_XStable_sort(_First, _Mid, _Count2, _Tempbuf);
            cliext::_XStable_sort(_Mid, _Last, _Count - _Count2, _Tempbuf);
            }

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

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

    if (_ISort::_Max < _Count)
        {   // 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<
    cliext::_XSort(_First, _Last, _Last - _First);
    }

template<class _RanIt> inline

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

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

inline

    {   // insertion sort [_First, _Last), using _Pred
    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_PRED(_Pred, _Val, *_First))
                {   // 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);

template<class _BidIt , class _Diff , class _Ty >

_BidIt _Buffered_rotate_unchecked ( const _BidIt  _First, const _BidIt  _Mid, const _BidIt  _Last, const _Diff  _Count1, const _Diff  _Count2, _Temporary_buffer< _Ty > &  _Temp_buf  )

inline

        {   // 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
    _PAIR_TYPE(_FwdIt) equal_range_unchecked(_FwdIt _First, _FwdIt _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  )

inline

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

        if (_Count2 <= _Tempbuf._Maxlen())
            {   // temp buffer big enough, sort each half using buffer
            cliext::_XBuffered_merge_sort(_First, _Mid, _Count2,
                _Tempbuf);
            cliext::_XBuffered_merge_sort(_Mid, _Last, _Count - _Count2,
                _Tempbuf);
            }
        else
            {   // 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,
            _Count2, _Count - _Count2, _Tempbuf);   // merge sorted halves
        }
    }

template<class _InIt , class _OutIt , class _Pr >

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

inline

    {   // find last [_First2, _Last2) match

template<class _InIt , class _OutIt , class _Pr >

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

inline

            {   // room for match, try it
            _FwdIt1 _Mid1 = _First1;
            for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1)

template<class _InIt , class _Pr >

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

inline

    {   // find first [_First2, _Last2) match

template<class _FwdIt , class _Ty , class _Pr >

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

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
        _BidIt _Firstn, _Lastn;
        _Diff _Count1n, _Count2n;
        if (_Count2 < _Count1)
            {   // 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, _Pred);
            _Iter_distance(_Mid, _Lastn, _Count2n);
            }
        else
            {   // 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,
                *_Lastn, _Pred);
            _Iter_distance(_First, _Firstn, _Count1n);
            }
        _BidIt _Midn = cliext::_XBuffered_rotate(_Firstn, _Mid, _Lastn,
            _Count1 - _Count1n, _Count2n, _Tempbuf);    // rearrange middle

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

_FwdIt1 _Find_end_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))
            *_Dest++ = *_First;
    return (_Dest);
    }

template<class _InIt,
    class _OutIt,
    class _Pr> inline
    _OutIt remove_copy_if(_InIt _First, _InIt _Last,
        _OutIt _Dest, _Pr _Pred)
    {   // 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 , class _Pr >

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

inline

    {   // remove each satisfying _Pred
    _First = cliext::find_if_unchecked(_First, _Last, _Pred);
    if (_First == _Last)

template<class _InIt , class _Pr >

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

inline

    {   // find first _Count * _Val satisfying _Pred
    _STLCLRDB_RANGE(_First1, _Last1);

template<class _InIt , class _Pr >

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

inline

    {   // count elements satisfying _Pred

template<class _InIt , class _Fn1 >

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

inline

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

template<class _OutIt , class _Diff , class _Fn0 >

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

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;
                _Rm = _Rm << _RANDOM_BITS | _RANDOM_MAX)
                _Rn = _Rn << _RANDOM_BITS

template<class _FwdIt , class _Fn0 >

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

inline

    {   // shuffle [_First, _Last)

template<class _RanIt , class _Pr >

void _Guess_median_unchecked ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, _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;
            }

_Distance_unknown _Idl_dist_add ( _Distance_unknown  , _Distance_unknown    )

inline

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

template<class _Diff1 >

_Distance_unknown _Idl_dist_add ( _Diff1  , _Distance_unknown    )

inline

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

template<class _Diff2 >

_Distance_unknown _Idl_dist_add ( _Distance_unknown  , _Diff2    )

inline

    {   // insertion sort [_First, _Last), using operator<

template<class _Diff1 , class _Diff2 >

auto _Idl_dist_add ( _Diff1  _Lhs, _Diff2  _Rhs  )

inline

            {   // order next element

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Includes_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _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 _BidIt , class _Pr >

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

inline

    {   // partition [_First, _Last), using _Pred
    _RanIt _Mid = _First + (_Last - _First) / 2;
    cliext::_XMedian(_First, _Mid, _Last - 1, _Pred);

template<class _BidIt , class _Pr >

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

inline

            {   // no room at bottom, rotate pivot upward
            if (_Plast != _Gfirst)
                cliext::iter_swap(_Pfirst, _Plast);
            ++_Plast;
            cliext::iter_swap(_Pfirst++, _Gfirst++);
            }
        else if (_Gfirst == _Last)
            {   // no room at top, rotate pivot downward
            if (--_Glast != --_Pfirst)

template<class _RanIt , class _Pr >

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

inline

    {   // reverse permute and test for pure descending, using _Pred
    _BidIt _Next = _Last;
    if (_First == _Last || _First == --_Next)
        return (false);

    for (; ; )
        {   // find rightmost element not smaller than successor
        _BidIt _Next1 = _Next;
        if (_STLCLRDB_LT_PRED(_Pred, *_Next1, *--_Next))
            {   // swap with rightmost element that's not smaller, flip suffix

template<class _InIt , class _Pr >

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

inline

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

template<class _FwdIt , class _Pr >

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

inline

template<class _FwdIt , class _Ty , class _Pr >

_FwdIt _Lower_bound_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _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, *_Lastn);
            _Iter_distance(_First, _Firstn, _Count1n);
            }

        _BidIt _Midn = cliext::_XBuffered_rotate(_Firstn, _Mid, _Lastn,
            _Count1 - _Count1n, _Count2n, _Tempbuf);    // rearrange middle
        cliext::_XBuffered_merge(_First, _Firstn, _Midn,
            _Count1n, _Count2n, _Tempbuf);  // merge each new part
        cliext::_XBuffered_merge(_Midn, _Lastn, _Last,
            _Count1 - _Count1n, _Count2 - _Count2n, _Tempbuf);
        }

template<class _RanIt , class _Pr >

void _Make_heap_unchecked ( _RanIt  _First, _RanIt  _Last, _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);
            _Iter_distance(_Mid, _Lastn, _Count2n);
            }
        else
            {   // right larger, cut it in half and partition left to match
            _Count1n = 0, _Count2n = _Count2 / 2;
            _Lastn = _Mid;
            cliext::advance(_Lastn, _Count2n);

template<class _FwdIt , class _Pr >

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

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

template<class _RanIt , class _Pr >

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

inline

    {   // order [_First, _Last), using _Pred
    _Diff _Count;

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

                {   // look for insertion point after first
                for (_BidIt _First1 = _Next1;
                    _STLCLRDB_LT(_Val, *--_First1);
                    _Next1 = _First1)
                    *_Next1 = *_First1; // move hole down
                *_Next1 = _Val; // insert element in hole
                }
            }
    }

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

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 [_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,

template<class _FwdIt , class _Pr >

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

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

template<class _FwdIt , class _Pr >

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

    {   // 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),
        _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest)));
    }

        // TEMPLATE FUNCTION set_symmetric_difference WITH PRED
template<class _InIt1,
    class _InIt2,
    class _OutIt,
    class _Pr> inline
    _OutIt set_symmetric_difference_unchecked(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
    {   // XOR sets [_First1, _Last1) and [_First2, _Last2), using _Pred
    for (; _First1 != _Last1 && _First2 != _Last2; )
        if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
            *_Dest++ = *_First1, ++_First1;
        else if (_Pred(*_First2, *_First1))
            *_Dest++ = *_First2, ++_First2;
        else
            ++_First1, ++_First2;
    _Dest = cliext::copy_unchecked(_First1, _Last1, _Dest);

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) satisfying _Pred
    _STLCLRDB_RANGE(_First1, _Last1);

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

        {   // room for match, try it
        _FwdIt1 _Mid1 = _First1;
        for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1, ++_Mid2)

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

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

template<class _BidIt , class _Pr >

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

inline

    {   // permute and test for pure ascending, using operator<
    _STLCLRDB_RANGE(_First, _Last);
    return (cliext::next_permutation_unchecked(
        _Unchecked(_First), _Unchecked(_Last)));
    }

        // TEMPLATE FUNCTION next_permutation WITH PRED
template<class _BidIt,
    class _Pr> inline
    bool next_permutation_unchecked(_BidIt _First, _BidIt _Last, _Pr _Pred)
    {   // permute and test for pure ascending, using _Pred
    _BidIt _Next = _Last;
    if (_First == _Last || _First == --_Next)
        return (false);

    for (; ; )
        {   // find rightmost element smaller than successor
        _BidIt _Next1 = _Next;
        if (_STLCLRDB_LT_PRED(_Pred, *--_Next, *_Next1))
            {   // swap with rightmost element that's smaller, flip suffix
            _BidIt _Mid = _Last;

const _Ty& _Right _NOEXCEPT_OP

(

_NOEXCEPT_OP(_DEBUG_LT(_Left, _Right))

)

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

const _Ty& _Right _NOEXCEPT_OP

(

_NOEXCEPT_OP(_DEBUG_LT(_Right, _Left))

)

    {   // find smallest element, using _Pred

template<class _InIt , class _Pr >

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

inline

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

template<class _RanIt , class _Pr >

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

inline

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

        if (_Count2 <= _Tempbuf._Maxlen())
            {   // 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);
            }

template<class _InIt , class _RanIt , class _Pr >

_RanIt _Partial_sort_copy_unchecked ( _InIt  _First1, _InIt  _Last1, _RanIt  _First2, _RanIt  _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);
        }
    }
#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
    if (_Count <= _ISort::_Max)
        cliext::_XInsertion_sort(_First, _Last, _Pred); // small
    else

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, _Pred);
        cliext::_XChunked_merge(_Tempbuf._First(), _Tempbuf._Last(), _First,
            _Chunk *= 2, _Count, _Pred);

template<class _RanIt , class _Pr >

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

inline

    {   // order [_First, _Last), using _Pred
    cliext::_XSort(_First, _Last, _Last - _First, _Pred);
    }

template<class _RanIt,
    class _Pr> inline
    void sort(_RanIt _First, _RanIt _Last, _Pr _Pred)
    {   // 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;
        cliext::advance(_Mid2, _Chunk);

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

    if (_Count <= _Chunk)
        cliext::copy_unchecked(_First, _Last,
            _Dest); // copy partial last chunk
    else
        {   // 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,

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

    {   // look for one of [_First2, _Last2) that matches element

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

                    {   // potential answer, save it
                    _Ans = _First1;
                    break;
                    }
            }
    return (_Ans);
    }

template<class _FwdIt1,
    class _FwdIt2,
    class _Pr> inline

template<class _FwdIt , class _Pr >

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

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 _FwdIt , class _Pr >

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

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 FUNCTION upper_bound
template<class _FwdIt,

template<class _BidIt , class _Pr >

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

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,

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

    {   // 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);
        return (_First);
        }
    }
#endif  // __cplusplus_cli

template<class _RanIt , class _Ty , class _Pr >

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

inline

    {   // merge backwards to _Dest, using operator<
    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(*--_Last2, *--_Last1))

template<class _RanIt , class _Pr >

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

inline

    {   // merge [_First, _Mid) with [_Mid, _Last), using operator<
    if (_Count1 + _Count2 == 2)

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

    {   // reverse permute and test for pure descending, using operator<
    _BidIt _Next = _Last;
    if (_First == _Last || _First == --_Next)
        return (false);
    for (; ; )
        {   // find rightmost element not smaller than successor
        _BidIt _Next1 = _Next;
        if (_STLCLRDB_LT(*_Next1, *--_Next))
            {   // swap with rightmost element that's not smaller, flip suffix
            _BidIt _Mid = _Last;
            for (; !_STLCLRDB_LT(*--_Mid, *_Next); )
                ;
            cliext::iter_swap(_Next, _Mid);
            cliext::reverse(_Next1, _Last);
            return (true);
            }

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

    {   //  copy merging ranges, both using _Pred
    _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
    _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::merge_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2),

template<class _RanIt , class _Pr >

void _Push_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 _RngFn >

void _Random_shuffle1 ( _RanIt  _First, _RanIt  _Last, _RngFn &  _RngFunc  )

inline

    {   // find first element not before _Val, using operator<

template<class _RanIt , class _RngFn >

void _Random_shuffle_unchecked ( _RanIt  _First, _RanIt  _Last, _RngFn &  _RngFunc  )

inline

    {   // order heap by repeatedly popping, using _Pred
    for (; 1 < _Last - _First; --_Last)
        cliext::pop_heap_unchecked(_First, _Last, _Pred);
    }

template<class _RanIt,
    class _Pr> inline
    void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred)
    {   // order heap by repeatedly popping, using _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    _STLCLRDB_HEAP_PRED(_First, _Last, _Pred);

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

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

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

template<class _InIt , class _OutIt , class _Pr >

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

inline

        {   // temp buffer big enough, copy right partition out and back
        _BidIt _Next = _First;
        for (_Tempbuf._Init(); _First != _Last; ++_First)
            if (_Pred(*_First))
                *_Next++ = *_First;
            else
                *_Tempbuf++ = *_First;

template<class _InIt , class _OutIt , class _Pr >

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

inline

    {   // partition preserving order of equivalents, using _Pred

template<class _InIt , class _OutIt , class _Ty >

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

inline

    {   // shuffle [_First, _Last) using random function _Func
    _STLCLRDB_RANGE(_First, _Last);

template<class _FwdIt , class _Pr >

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

inline

    {   // partition preserving order of equivalents, using _Pred

template<class _FwdIt , class _Ty >

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

inline

    {   // partition preserving order of equivalents, using _Pred
    if (_Count == 0)
        return (_First);
    else if (_Count == 1)
        return (_Pred(*_First) ? _Last : _First);
    else if (_Count <= _Tempbuf._Maxlen())
        {   // temp buffer big enough, copy right partition out and back
        _BidIt _Next = _First;
        for (_Tempbuf._Init(); _First != _Last; ++_First)
            if (_Pred(*_First))

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

    {   // 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_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr &  _Pred, const _Ty &  _Val  )

inline

            {   // rotate each subcycle
            _RanIt _Hole = _First + _Count;
            _RanIt _Next = _Hole;
            _Ty _Holeval = *_Hole;
            _RanIt _Next1 = _Next + _Shift == _Last ? _First : _Next + _Shift;
            while (_Next1 != _Hole)
                {   // percolate elements back around subcycle
                *_Next = *_Next1;
                _Next = _Next1;
                _Next1 = _Shift < _Last - _Next1 ? _Next1 + _Shift
                    : _First + (_Shift - (_Last - _Next1));
                }
            *_Next = _Holeval;
            }

template<class _InIt , class _OutIt , class _Ty >

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

inline

    {   // copy reversing elements in [_First, _Last)
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::reverse_copy_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Unchecked(_Dest)));
    }

        // TEMPLATE FUNCTION rotate
template<class _FwdIt> inline
    void _Rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last,
        forward_iterator_tag)
    {   // rotate [_First, _Last), forward iterators
    for (_FwdIt _Next = _Mid; ; )
        {   // swap [_First, ...) into place

template<class _FwdIt , class _Pr , class _Ty >

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

inline

    {   // reverse elements in [_First, _Last)
    _Reverse(_First, _Last, _Iter_category(_First));
    }

template<class _BidIt> inline
    void reverse(_BidIt _First, _BidIt _Last)

template<class _FwdIt , class _Ty >

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

inline

    {   // reverse elements in [_First, _Last), bidirectional iterators

template<class _BidIt , class _OutIt >

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

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)
        {   // move _Hole down to larger child

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 operator<
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_HEAP(_First, _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

    {   // 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)
        *_Dest = _Pred(*_First) ? _Val : *_First;
    return (_Dest);
    }

template<class _InIt,
    class _OutIt,

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 [_First, _Last) with _Func()
    for (; _First != _Last; ++_First)
        *_First = _Func();
    }

template<class _FwdIt,
    class _Fn0> inline
    void generate(_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
    {   // 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()

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

    {   // transform [_First1, _Last1) and [_First2, _Last2) with _Func
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_POINTER(_First2);
    _STLCLRDB_POINTER(_Dest);
    _STLCLRDB_POINTER(_Func);
    return (cliext::transform_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Dest, _Func));
    }

        // TEMPLATE FUNCTION replace
template<class _FwdIt,
    class _Ty> inline
    void replace_unchecked(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Oldval, const _Ty% _Newval)
    {   // replace each matching _Oldval with _Newval

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

    {   // 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)

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

    {   // test if set [_First1, _Last1) in [_First2, _Last2), using _Pred
    for (; _First1 != _Last1 && _First2 != _Last2; )
        if (_STLCLRDB_LT_PRED(_Pred, *_First2, *_First1))
            return (false);
        else if (_Pred(*_First1, *_First2))
            ++_First1;
        else
            ++_First1, ++_First2;
    return (_First2 == _Last2);
    }

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

    {   // test if all [_First1, _Last1) in [_First2, _Last2), using operator<
    _STLCLRDB_ORDER(_First1, _Last1);
    _STLCLRDB_ORDER(_First2, _Last2);
    return (cliext::includes_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 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)
            _First = _Mid.second;
        else if (_Mid.first <= _Nth)
            return; // Nth inside fat pivot, done

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

    {   // copy [First1, _Last1) into [_First2, _Last2) using _Pred
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_RANGE(_First2, _Last2);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::partial_sort_copy_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _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

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

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

    {   // OR 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_union_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest), _Pred));
    }

        // TEMPLATE FUNCTION set_intersection
template<class _InIt1,
    class _InIt2,
    class _OutIt> inline

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

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

    if (_First1 == _Last1 || _First2 == _Last2)
        return (_First2);
    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

    {   // order [First, _Last) up to _Mid, using _Pred
    typedef iterator_traits<_RanIt>::value_type _Ty;

    cliext::make_heap_unchecked(_First, _Mid, _Pred);

    for (_RanIt _Next = _Mid; _Next < _Last; ++_Next)
        if (_STLCLRDB_LT_PRED(_Pred, *_Next, *_First))
            _XPop_heap(_First, _Mid, _Next,
                _Ty(*_Next), _Pred);    // replace top with new largest
    cliext::sort_heap_unchecked(_First, _Mid, _Pred);
    }

template<class _RanIt,
    class _Pr> inline
    void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
    {   // order [First, _Last) up to _Mid, using _Pred
    _STLCLRDB_RANGE(_First, _Mid);
    _STLCLRDB_RANGE(_Mid, _Last);
    _STLCLRDB_POINTER(_Pred);
    cliext::partial_sort_unchecked(

template<class _RanIt , class _Pr >

void _Sort_heap_unchecked ( _RanIt  _First, _RanIt  _Last, _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))

template<class _RanIt , class _Pr >

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

inline

template<class _RanIt , class _Diff , class _Pr >

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

inline

    {   // 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);
        _Mid = _Midend;
        }
    cliext::_XInsertion_sort(_Mid, _Last);  // sort partial last chunk

    for (_Diff _Chunk = _ISort::_Max; _Chunk < _Count; _Chunk *= 2)
        {   // 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);
        }
    }

#if __cplusplus_cli
template<class _BidIt,
    class _Diff,
    class _Ty> inline
    void _XBuffered_merge_sort(_BidIt _First, _BidIt _Last, _Diff _Count,
        _Temp_gc_iterator<_Ty> _Tempbuf)
    {   // sort using temp buffer for merges, using operator<
    _BidIt _Mid = _First;

template<class _BidIt , class _Pr >

_BidIt _Stable_partition_unchecked ( _BidIt  _First, _BidIt  _Last, _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
    bool binary_search(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred)
    {   // test if _Val equivalent to some element, using _Pred
    _STLCLRDB_ORDER_PRED(_First, _Last, _Pred);
    return (cliext::binary_search_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Val, _Pred));
    }

        // TEMPLATE FUNCTION merge
template<class _InIt1,
    class _InIt2,
    class _OutIt> inline
    _OutIt merge_unchecked(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)

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

pair<_BidIt, _Diff> _Stable_partition_unchecked1 ( _BidIt  _First, _BidIt  _Last, _Pr &  _Pred, const _Diff  _Count, _Temporary_buffer< _Ty > &  _Temp_buf  )

inline

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

        if (_STLCLRDB_LT(*_Mid, _Val))
            {   // range begins above _Mid, loop
            _First = ++_Mid;
            _Count -= _Count2 + 1;
            }
        else if (_Val < *_Mid)
            _Count = _Count2;   // range in first half, loop
        else
            {   // range straddles mid, find each end and return
            _FwdIt _First2 = lower_bound(_First, _Mid, _Val);
            cliext::advance(_First, _Count);
            _FwdIt _Last2 = upper_bound(++_Mid, _First, _Val);
            return (_PAIR_TYPE(_FwdIt)(_First2, _Last2));
            }
        }

    return (_PAIR_TYPE(_FwdIt)(_First, _First));    // empty range
    }

template<class _FwdIt,
    class _Ty> inline
    _PAIR_TYPE(_FwdIt) equal_range(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val)
    {   // find range equivalent to _Val, using operator<
    _STLCLRDB_ORDER(_First, _Last);
    return (cliext::equal_range_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Val));
    }

        // TEMPLATE FUNCTION equal_range WITH PRED
template<class _FwdIt,
    class _Ty,
    class _Pr> inline
    _PAIR_TYPE(_FwdIt) equal_range_unchecked(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred)
    {   // find range equivalent to _Val, using _Pred
    typedef iterator_traits<_FwdIt>::difference_type _Diff;

    _Diff _Count = 0;
    _Iter_distance(_First, _Last, _Count);

    for (; 0 < _Count; )
        {   // 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;
            _Count -= _Count2 + 1;
            }
        else if (_Pred(_Val, *_Mid))
            _Count = _Count2;   // range in first half, loop
        else
            {   // 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));
            }
        }

    return (_PAIR_TYPE(_FwdIt)(_First, _First));    // empty range
    }

template<class _FwdIt,
    class _Ty,
    class _Pr> inline
    _PAIR_TYPE(_FwdIt) equal_range(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Val, _Pr _Pred)
    {   // find range equivalent to _Val, using _Pred
    _STLCLRDB_ORDER_PRED(_First, _Last, _Pred);
    return (cliext::equal_range_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Val, _Pred));
    }

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

template<class _BidIt , class _Pr >

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

inline

    {   // copy merging chunks, using _Pred
    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;
        cliext::advance(_Mid2, _Chunk);

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

    if (_Count <= _Chunk)
        cliext::copy_unchecked(_First, _Last,
            _Dest); // copy partial last chunk
    else

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

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

inline

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

    if (_First != _Last)
        {   // 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);
        }
    }

template<class _BidIt> inline
    void stable_sort(_BidIt _First, _BidIt _Last)
    {   // 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,

template<class _FwdIt1 , class _FwdIt2 >

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

inline

    {   // remove each matching previous

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, forward iterators

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, input iterators
    typedef iterator_traits<_InIt>::value_type _Ty;

    _Ty _Val = *_First;

template<class _InIt , class _OutIt , class _Fn1 >

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

inline

    {   // copy compressing pairs that match, input iterators

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

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

inline

        : _Unique_copy(_First, _Last, _Dest, _Iter_category(_First)));
    }

template<class _InIt,
    class _OutIt> inline
    _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest)
    {   // copy compressing pairs that match

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(_First, _Last - 1);
        cliext::push_heap_unchecked(_Unchecked(_First), _Unchecked(_Last));
        }
    }

        // TEMPLATE FUNCTION push_heap WITH PRED
template<class _RanIt,
    class _Diff,
    class _Ty,

template<class _FwdIt , class _OutIt , class _Pr >

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

inline

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

    _Diff _Size = _Last - _First;
    if (2 <= _Size)
        for (_Diff _Off = 0; ++_Off < _Size; )
            if (_STLCLRDB_LT_PRED(_Pred, *(_First + (_Off - 1) / 2),
                *(_First + _Off)))
                _STLCLRDB_ERROR(L"invalid heap");
    }

  #define _STLCLRDB_HEAP(first, last)   \

template<class _InIt , class _FwdIt , class _Pr >

_FwdIt _Unique_copy_unchecked ( _InIt  _First, _InIt  _Last, _FwdIt  _Dest, _Pr &  _Pred, false_type  , true_type    )

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)

template<class _InIt , class _OutIt , class _Pr >

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

inline

    {   // push *(_Last - 1) onto heap at [_First, _Last - 1), using operator<
    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));
    }

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

template<class _FwdIt , class _Pr >

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

inline

        {   // partition nontrivial sequence
        _Diff _Count = 0;
        _Iter_distance(_First, _Last, _Count);
        _TEMP_ITER(_BidIt, _Ty) _Tempbuf(_Count);

        return (cliext::_XStable_partition(_First, _Last, _Pred, _Count,
            _Tempbuf));
        }
    }

template<class _BidIt,
    class _Pr> inline
    _BidIt stable_partition(_BidIt _First, _BidIt _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<
    _STLCLRDB_ORDER(_First, _Mid);
    _STLCLRDB_ORDER(_Mid, _Last);
    cliext::inplace_merge_unchecked(
        _Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last));
    }

        // TEMPLATE FUNCTION inplace_merge WITH PRED
template<class _BidIt1,
    class _BidIt2,
    class _BidIt3,
    class _Pr> inline
    _BidIt3 _XMerge_backward(_BidIt1 _First1, _BidIt1 _Last1,
        _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Pr _Pred)
    {   // 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))

template<class _FwdIt , class _Pr >

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

inline

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

template<class _FwdIt >

_FwdIt adjacent_find ( _FwdIt  _First, _FwdIt  _Last  )

inline

        {   // room for match, try it

template<class _InIt , class _Pr >

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

inline

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

template<class _InIt , class _Pr >

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

inline

            {   // found part of possible match, check it out
            _Diff2 _Count1 = _Count;
            _FwdIt1 _Mid1  = _First1;

template<class _FwdIt , class _Ty , class _Pr >

bool binary_search ( _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, _Pred);

template<class _FwdIt , class _Ty >

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

inline

template<class _InIt , class _OutIt , class _Pr >

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

inline

    {   // find last [_First2, _Last2) satisfying _Pred

template<class _InIt , class _Pr >

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

inline

    {   // find first [_First2, _Last2) satisfying _Pred

template<class _FwdIt , class _Ty , class _Pr >

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

inline

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

template<class _FwdIt , class _Ty >

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

inline

        {   // order two one-element partitions
        if (_STLCLRDB_LT_PRED(_Pred, *_Mid, *_First))
            cliext::iter_swap(_First, _Mid);
        }
    else if (_Count1 <= _Count2 && _Count1 <= _Tempbuf._Maxlen())

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

    {   // remove each matching _Val
    _First = cliext::find_unchecked(_First, _Last, _Val);
    if (_First == _Last)
        return (_First);    // empty sequence, all done

template<class _FwdIt1 , class _FwdIt2 >

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

inline

    {   // remove each matching _Val

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

    {   // remove each satisfying _Pred

template<class _FwdIt1 , class _FwdIt2 >

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

inline

    {   // remove each matching previous

template<class _InIt , class _Pr >

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

inline

template<class _InIt , class _Pr >

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

inline

    {   // find last [_First2, _Last2) match

template<class _InIt , class _Fn1 >

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

inline

    {   // count elements that match _Val

template<class _FwdIt , class _Fn0 >

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

inline

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

    if (_First != _Last)
        {   // shuffle nontrivial [_First, _Last)

template<class _OutIt , class _Diff , class _Fn0 >

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

inline

    {   // shuffle [_First, _Last)

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

    {   // order [First, _Last) up to _Mid, using operator<
    typedef iterator_traits<_RanIt>::value_type _Ty;

    cliext::make_heap_unchecked(_First, _Mid);

    for (_RanIt _Next = _Mid; _Next < _Last; ++_Next)
        if (_STLCLRDB_LT(*_Next, *_First))

template<class _InIt1 , class _InIt2 >

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

inline

    {   // order [First, _Last) up to _Mid, using operator<
    _STLCLRDB_RANGE(_First, _Mid);
    _STLCLRDB_RANGE(_Mid, _Last);

template<class _BidIt , class _Pr >

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

inline

        {   // partition

template<class _BidIt >

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

inline

        {   // partition

template<class _RanIt , class _Pr >

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

inline

    {   // reverse permute and test for pure descending, using _Pred

template<class _RanIt >

bool is_heap ( _RanIt  _First, _RanIt  _Last  )

inline

template<class _RanIt , class _Pr >

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

inline

            {   // pure ascending, flip all

template<class _RanIt >

_RanIt is_heap_until ( _RanIt  _First, _RanIt  _Last  )

inline

template<class _InIt , class _Pr >

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

inline

    {   // transform [_First, _Last) with _Func

template<class _FwdIt , class _Pr >

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

inline

template<class _FwdIt >

bool is_sorted ( _FwdIt  _First, _FwdIt  _Last  )

inline

template<class _FwdIt , class _Pr >

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

inline

template<class _FwdIt >

_FwdIt is_sorted_until ( _FwdIt  _First, _FwdIt  _Last  )

inline

template<class _FwdIt , class _Ty , class _Pr >

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

inline

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

    if (_First != _Mid && _Mid != _Last)
        {   // merge nontrivial sequence

template<class _FwdIt , class _Ty >

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

inline

                                                 : _Count2);

        cliext::_XBuffered_merge(_First, _Mid, _Last,

template<class _RanIt , class _Pr >

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

inline

template<class _RanIt >

void make_heap ( _RanIt  _First, _RanIt  _Last  )

inline

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

template<class _Ty , class _Pr >

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

inline

template<class _Ty , class _Pr >

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

    {   // find largest element, using operator<
    _STLCLRDB_RANGE(_First, _Last);

template<class _Ty >

_CONSTEXPR14 _Ty() max

(

initializer_list< _Ty >

_Ilist

)

    {   // find largest element, using _Pred

template<class _FwdIt , class _Pr >

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

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

template<class _FwdIt >

_CONSTEXPR14 _FwdIt max_element	(	_FwdIt	_First,
		_FwdIt	_Last
	)

    {   //  take set [_First2, _Last2) from [_First1, _Last1), using _Pred
    for (; _First1 != _Last1 && _First2 != _Last2; )
        if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
            *_Dest++ = *_First1, ++_First1;

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

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

inline

    {   // sort median element to middle

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

        {   // partition

template<class _Ty , class _Pr >

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

inline

template<class _Ty , class _Pr >

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

    {   // find smallest element, using operator<

template<class _Ty >

_CONSTEXPR14 _Ty() min

(

initializer_list< _Ty >

_Ilist

)

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

template<class _FwdIt , class _Pr >

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

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

template<class _FwdIt >

_CONSTEXPR14 _FwdIt min_element	(	_FwdIt	_First,
		_FwdIt	_Last
	)

    {   // XOR 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

    {   // find smallest element, using _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);

template<class _Ty , class _Pr >

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

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

template<class _Ty >

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

inline

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

template<class _Ty >

_CONSTEXPR14 pair<_Ty, _Ty> minmax

(

initializer_list< _Ty >

_Ilist

)

            {   // pure descending, flip all

template<class _FwdIt , class _Pr >

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

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

template<class _FwdIt >

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

    {   // find largest element, using operator<

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

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

template<class _InIt1 , class _InIt2 >

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

inline

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

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

    {   // find first _Count * _Val match
    _STLCLRDB_RANGE(_First1, _Last1);
    return (_Search_n(_Unchecked(_First1), _Unchecked(_Last1),
        _Count, _Val, _Iter_category(_First1)));

template<class _InIt1 , class _InIt2 >

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

inline

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

template<class _BidIt , class _Pr >

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

inline

            {   // pure descending, flip all

template<class _BidIt >

bool next_permutation ( _BidIt  _First, _BidIt  _Last  )

inline

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

template<class _InIt , class _Pr >

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

inline

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

template<class _RanIt , class _Pr >

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

inline

    {   // sort preserving order of equivalents, using _Pred

template<class _RanIt >

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

inline

    {   // sort preserving order of equivalents, using _Pred

template<class _RanIt , class _Pr >

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

inline

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

template<class _RanIt >

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

inline

        {   // sort chunks
        _BidIt _Midn = _Mid;
        cliext::advance(_Midn, (int)_ISort::_Max);

template<class _InIt , class _RanIt , class _Pr >

_RanIt partial_sort_copy ( _InIt  _First1, _InIt  _Last1, _RanIt  _First2, _RanIt  _Last2, _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
            {   // temp buffer not big enough, divide and conquer

template<class _InIt , class _RanIt >

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

inline

    {   // sort preserving order of equivalents, using _Pred

template<class _FwdIt , class _Pr >

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

inline

    {   // find first element that _Val is before, using _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

    {   // look for one of [_First2, _Last2) that matches element

template<class _FwdIt , class _Pr >

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

inline

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

template<class _RanIt , class _Pr >

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

inline

        {   // buffer left partition, then merge
        cliext::copy_unchecked(_First, _Mid, _Tempbuf._Init());
        cliext::merge_unchecked(_Tempbuf._First(), _Tempbuf._Last(),
            _Mid, _Last, _First);

template<class _RanIt >

void pop_heap ( _RanIt  _First, _RanIt  _Last  )

inline

        {   // buffer too small, divide and conquer

template<class _BidIt , class _Pr >

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

inline

    {   // reverse permute and test for pure descending, using operator<

template<class _BidIt >

bool prev_permutation ( _BidIt  _First, _BidIt  _Last  )

inline

    {   // reverse permute and test for pure descending, using _Pred

template<class _RanIt , class _Pr >

void push_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);

template<class _RanIt >

void push_heap ( _RanIt  _First, _RanIt  _Last  )

inline

        {   // buffer too small, rotate in place
        cliext::rotate_unchecked(_First, _Mid, _Last);
        cliext::advance(_First, _Count2);

template<class _FwdIt , class _Ty >

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

inline

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

template<class _InIt , class _OutIt , class _Ty >

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

inline

    {   // move elements satisfying _Pred to beginning of sequence
    for (; ; ++_First)
        {   // find any out-of-order pair
        for (; _First != _Last && _Pred(*_First); ++_First)
            ;   // skip in-place elements at beginning

template<class _InIt , class _OutIt , class _Pr >

_OutIt remove_copy_if ( _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,

template<class _FwdIt , class _Pr >

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

inline

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

template<class _FwdIt , class _Ty >

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

inline

    {   // reverse elements in [_First, _Last), random-access iterators
    for (; _First < _Last; ++_First)

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), bidirectional iterators

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

    {   // copy rotating [_First, _Last)
    _Dest = cliext::copy_unchecked(_Mid, _Last, _Dest);

template<class _FwdIt , class _Pr , class _Ty >

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

inline

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

template<class _BidIt , class _OutIt >

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

inline

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

template<class _RanIt,

template<class _FwdIt , class _OutIt >

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

inline

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

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

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<class _FwdIt1 , class _FwdIt2 >

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

inline

    {   // copy replacing each matching _Oldval with _Newval
    for (; _First != _Last; ++_First, ++_Dest)

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 omitting each matching _Val
    for (; _First != _Last; ++_First)

template<class _FwdIt , class _Diff , class _Ty >

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

inline

    {   // copy omitting each matching _Val

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

    {   // test if set [_First1, _Last1) in [_First2, _Last2), using _Pred
    _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
    _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
    return (cliext::includes_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Pred));

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

    {   // OR sets [_First1, _Last1) and [_First2, _Last2), using operator<
    _STLCLRDB_ORDER(_First1, _Last1);
    _STLCLRDB_ORDER(_First2, _Last2);
    _STLCLRDB_POINTER(_Dest);

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 Nth element, using operator<
    _STLCLRDB_RANGE(_First, _Nth);

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

    {   // order Nth element, using _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  )

inline

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

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

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

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

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

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

template<class _RanIt , class _Urng >

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

inline

        {   // divide and conquer, find half that contains answer
        _Diff _Count2 = _Count / 2;

template<class _RanIt , class _Pr >

void sort ( _RanIt  _First, _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,

template<class _RanIt >

void sort ( _RanIt  _First, _RanIt  _Last  )

inline

    {   //  sort preserving order of equivalents, using operator<

template<class _RanIt , class _Pr >

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

inline

        {   // 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())

template<class _RanIt >

void sort_heap ( _RanIt  _First, _RanIt  _Last  )

inline

        {   // buffer too small, divide and conquer

template<class _BidIt , class _Pr >

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

inline

    {   // copy merging ranges, both using operator<

template<class _BidIt , class _Pr >

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

inline

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

template<class _BidIt >

void stable_sort ( _BidIt  _First, _BidIt  _Last  )

inline

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

template<class _FwdIt1 , class _FwdIt2 >

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

inline

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

template<class _InIt , class _OutIt , class _Fn1 >

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

inline

    {   // copy compressing pairs that match, bidirectional 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, forward iterators

template<class _FwdIt , class _Pr >

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

inline

    {   // test if range is a heap ordered by operator<

template<class _FwdIt >

_FwdIt unique ( _FwdIt  _First, _FwdIt  _Last  )

inline

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

template<class _InIt , class _OutIt , class _Pr >

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

inline

        {   // move _Hole up to parent
        *(_First + _Hole) = *(_First + _Idx);
        _Hole = _Idx;

template<class _InIt , class _OutIt >

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

inline

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

template<class _FwdIt , class _Ty , class _Pr >

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

inline

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

template<class _FwdIt , class _Ty >

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

inline

        {   // buffer left partition, then merge

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