algorithm File Reference

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

Classes
struct	_Rand_urng_from_func
class	cliext::_ISort

Namespaces
	cliext

Macros
#define	_ALGORITHM_
#define	_DEBUG_HEAP(first, last)
#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 _InIt , class _Fn1 >
void	_For_each (_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 (_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 (_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 (_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 (_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 _InIt , class _Pr >
bool	_All_of (_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 (_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 (_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 (_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 (_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 (_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 (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _InIt , class _Pr >
bool	is_partitioned (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _FwdIt , class _Diff , class _Pr >
_FwdIt	_Partition_point (_FwdIt _First, _FwdIt _Last, _Pr _Pred, _Diff *)
template<class _FwdIt , class _Pr >
_FwdIt	partition_point (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Diff1 , class _Diff2 , class _Pr >
_FwdIt1	_Search (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred, _Diff1 *, _Diff2 *)
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 _FwdIt1 , class _Diff2 , class _Ty , class _Pr >
_FwdIt1	_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	_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	search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty &_Val, _Pr _Pred)
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1	search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty &_Val)
template<class _FwdIt1 , class _FwdIt2 , class _Diff1 , class _Diff2 , class _Pr >
_FwdIt1	_Find_end (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred, _Diff1 *, _Diff2 *)
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 (_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 (_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 (_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 (_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 (_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 (_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 (_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 (_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 (_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 (_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 (_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 (_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 (_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 (_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 (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	unique (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	unique (_FwdIt _First, _FwdIt _Last)
template<class _InIt , class _OutIt , class _Ty , class _Pr >
_OutIt	_Unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Ty *)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	_Unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, input_iterator_tag)
template<class _FwdIt , class _OutIt , class _Pr >
_OutIt	_Unique_copy (_FwdIt _First, _FwdIt _Last, _OutIt _Dest, _Pr _Pred, forward_iterator_tag)
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 (_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 (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
template<class _RanIt , class _Fn1 , class _Diff >
void	_Random_shuffle (_RanIt _First, _RanIt _Last, _Fn1 &_Func, _Diff *)
template<class _RanIt , class _Fn1 >
void	random_shuffle (_RanIt _First, _RanIt _Last, _Fn1 &&_Func)
template<class _RanIt , class _Urng >
void	shuffle (_RanIt _First, _RanIt _Last, _Urng &&_Func)
template<class _RanIt >
void	random_shuffle (_RanIt _First, _RanIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	_Partition (_FwdIt _First, _FwdIt _Last, _Pr _Pred, forward_iterator_tag)
template<class _BidIt , class _Pr >
_BidIt	_Partition (_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 (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > &_Tempbuf)
template<class _BidIt , class _Pr , class _Diff , class _Ty >
_BidIt	_Stable_partition (_BidIt _First, _BidIt _Last, _Pr _Pred, _Diff _Count, _Temp_iterator< _Ty > &_Tempbuf)
template<class _BidIt , class _Pr , class _Diff , class _Ty >
_BidIt	_Stable_partition (_BidIt _First, _BidIt _Last, _Pr _Pred, _Diff *, _Ty *)
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 (_RanIt _First, _Diff _Hole, _Diff _Top, _Ty &&_Val, _Pr _Pred)
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void	_Push_heap_0 (_RanIt _First, _RanIt _Last, _Pr _Pred, _Diff *, _Ty *)
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	_Adjust_heap (_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty &&_Val, _Pr _Pred)
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void	_Pop_heap (_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty &&_Val, _Pr _Pred, _Diff *)
template<class _RanIt , class _Ty , class _Pr >
void	_Pop_heap_0 (_RanIt _First, _RanIt _Last, _Pr _Pred, _Ty *)
template<class _RanIt , class _Pr >
void	_Pop_heap (_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 _Diff , class _Ty , class _Pr >
void	_Make_heap (_RanIt _First, _RanIt _Last, _Pr _Pred, _Diff *, _Ty *)
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 (_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 _Diff , class _Pr >
_FwdIt	_Lower_bound (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr _Pred, _Diff *)
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 _Diff , class _Pr >
_FwdIt	_Upper_bound (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr _Pred, _Diff *)
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 _Diff , class _Pr >
pair< _FwdIt, _FwdIt >	_Equal_range (_FwdIt _First, _FwdIt _Last, const _Ty &_Val, _Pr _Pred, _Diff *)
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 (_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	_Merge0 (_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	_Merge_backward (_BidIt1 _First1, _BidIt1 _Last1, _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _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 _BidIt , class _Diff , class _Ty , class _Pr >
void	_Buffered_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > &_Tempbuf, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	_Inplace_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred, _Diff *, _Ty *)
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 , class _Ty >
void	_Insertion_sort1 (_BidIt _First, _BidIt _Last, _Pr _Pred, _Ty *)
template<class _BidIt , class _Pr >
void	_Insertion_sort (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	_Med3 (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	_Median (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
pair< _RanIt, _RanIt >	_Unguarded_partition (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Diff , class _Pr >
void	_Sort (_RanIt _First, _RanIt _Last, _Diff _Ideal, _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 (_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 (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > &_Tempbuf, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	_Stable_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > &_Tempbuf, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	_Stable_sort (_BidIt _First, _BidIt _Last, _Diff *, _Ty *, _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 _Ty , class _Pr >
void	_Partial_sort (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred, _Ty *)
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 _Diff , class _Ty , class _Pr >
_RanIt	_Partial_sort_copy (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred, _Diff *, _Ty *)
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 (_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 (_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 (_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 (_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 (_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 (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	set_symmetric_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	set_symmetric_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _FwdIt , class _Pr >
_FwdIt	_Max_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	max_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	max_element (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	_Min_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	min_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	min_element (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
pair< _FwdIt, _FwdIt >	_Minmax_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
pair< _FwdIt, _FwdIt >	minmax_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
pair< _FwdIt, _FwdIt >	minmax_element (_FwdIt _First, _FwdIt _Last)
template<class _Ty >
	_Post_equal_to_ (_Left< _Right?_Right:_Left) const _Ty &(max)(const _Ty &_Left
template<class _Ty >
_Ty()	max (_XSTD initializer_list< _Ty > _Ilist)
template<class _Ty , class _Pr >
const _Ty &()	max (const _Ty &_Left, const _Ty &_Right, _Pr _Pred)
template<class _Ty , class _Pr >
_Ty()	max (_XSTD initializer_list< _Ty > _Ilist, _Pr _Pred)
template<class _Ty >
	_Post_equal_to_ (_Right< _Left?_Right:_Left) const _Ty &(min)(const _Ty &_Left
template<class _Ty >
_Ty()	min (_XSTD initializer_list< _Ty > _Ilist)
template<class _Ty , class _Pr >
const _Ty &()	min (const _Ty &_Left, const _Ty &_Right, _Pr _Pred)
template<class _Ty , class _Pr >
_Ty()	min (_XSTD initializer_list< _Ty > _Ilist, _Pr _Pred)
template<class _Ty >
pair< const _Ty &, const _Ty & >	minmax (const _Ty &_Left, const _Ty &_Right)
template<class _Ty >
pair< _Ty, _Ty >	minmax (_XSTD initializer_list< _Ty > _Ilist)
template<class _Ty , class _Pr >
pair< const _Ty &, const _Ty & >	minmax (const _Ty &_Left, const _Ty &_Right, _Pr _Pred)
template<class _Ty , class _Pr >
pair< _Ty, _Ty >	minmax (_XSTD initializer_list< _Ty > _Ilist, _Pr _Pred)
template<class _BidIt , class _Pr >
bool	_Next_permutation (_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 (_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 _Diff , class _Pr >
_RanIt	_Is_heap_until (_RanIt _First, _RanIt _Last, _Pr _Pred, _Diff *)
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 (_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
const _Ty &	_Right
const _Ty &	_Right
_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	(		first,
			last
	)

#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 ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

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

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

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

inline

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

template<class _InIt , class _Pr >

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

inline

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

template<class _InIt , class _Pr >

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

inline

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

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

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

inline

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

template<class _BidIt,
    class _Diff,
    class _Ty> inline
    void _XStable_sort(_BidIt _First, _BidIt _Last, _Diff _Count,
        _Temp_iterator<_Ty> _Tempbuf)
    {   //  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);
            }

        cliext::_XBuffered_merge(_First, _Mid, _Last,
            _Count2, _Count - _Count2, _Tempbuf);   // merge sorted halves
        }
    }

#if __cplusplus_cli
template<class _BidIt,
    class _Diff,

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

void _Buffered_merge_sort ( _BidIt  _First, _BidIt  _Last, _Diff  _Count, _Temp_iterator< _Ty > &  _Tempbuf, _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))
            _XPop_heap(_First, _Mid, _Next,
                _Ty(*_Next));   // replace top with new largest
    cliext::sort_heap_unchecked(_First, _Mid);
    }

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

template<class _BidIt , class _Diff , class _Ty >

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

inline

        {   // 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 _BidIt1,
    class _BidIt2,
    class _BidIt3> inline

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

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

inline

    {   // sort preserving order of equivalents, using _Pred
    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, _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(

template<class _InIt , class _OutIt , class _Pr >

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

inline

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

template<class _InIt , class _Pr >

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

inline

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

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

pair<_FwdIt, _FwdIt> _Equal_range ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr  _Pred, _Diff *    )

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)

template<class _FwdIt1 , class _FwdIt2 , class _Diff1 , class _Diff2 , class _Pr >

_FwdIt1 _Find_end ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr  _Pred, _Diff1 *  , _Diff2 *    )

inline

    {   // replace [_Dest, _Dest + _Count) with _Func()
    for (; 0 < _Count; --_Count, ++_Dest)
        *_Dest = _Func();
    }

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

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

_FwdIt1 _Find_first_of ( _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 _Pr >

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

inline

    {   // find first matching _Val

template<class _InIt , class _Pr >

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

inline

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

template<class _InIt , class _Fn1 >

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

inline

    {   // perform function for each element

template<class _FwdIt , class _Fn0 >

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

inline

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

    _Diff _Size = _Last - _First;

template<class _OutIt , class _Diff , class _Fn0 >

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

inline

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

template<class _InIt1 , class _InIt2 , class _Pr >

bool _Includes ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _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 FUNCTION includes WITH PRED
template<class _InIt1,
    class _InIt2,

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

void _Inplace_merge ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last, _Pr  _Pred, _Diff *  , _Ty *    )

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

template<class _BidIt , class _Pr >

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

inline

template<class _BidIt , class _Pr , class _Ty >

void _Insertion_sort1 ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred, _Ty *    )

inline

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

        // TEMPLATE FUNCTION stable_sort WITH PRED
template<class _BidIt,
    class _OutIt,
    class _Diff,
    class _Pr> inline
    void _XChunked_merge(_BidIt _First, _BidIt _Last, _OutIt _Dest,
        _Diff _Chunk, _Diff _Count, _Pr _Pred)
    {   // copy merging chunks, using _Pred
    for (_Diff _Chunk2 = _Chunk * 2; _Chunk2 <= _Count; _Count -= _Chunk2)

template<class _RanIt , class _Diff , class _Pr >

_RanIt _Is_heap_until ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred, _Diff *    )

inline

template<class _InIt , class _Pr >

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

inline

    {   // look for one of [_First2, _Last2) satisfying _Pred with element

template<class _FwdIt , class _Pr >

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

inline

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

_FwdIt _Lower_bound ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr  _Pred, _Diff *    )

inline

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

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

    if (_First != _Last)
        for (_BidIt _Next = _First; ++_Next != _Last; )

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

void _Make_heap ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred, _Diff *  , _Ty *    )

inline

        {   // buffer left partition, then merge
        cliext::copy_unchecked(_First, _Mid, _Tempbuf._Init());
        cliext::merge_unchecked(_Tempbuf._First(), _Tempbuf._Last(),
            _Mid, _Last, _First, _Pred);
        }
    else if (_Count2 <= _Tempbuf._Maxlen())
        {   // buffer right partition, then merge
        cliext::copy_unchecked(_Mid, _Last, _Tempbuf._Init());
        cliext::_XMerge_backward(_First, _Mid,
            _Tempbuf._First(), _Tempbuf._Last(), _Last, _Pred);

template<class _FwdIt , class _Pr >

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

inline

     :0009 */

template<class _RanIt , class _Pr >

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

inline

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

        cliext::merge_unchecked(_First, _Mid1,
            _Mid1, _Last, _Dest, _Pred);

template<class _RanIt , class _Pr >

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

inline

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

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

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

inline

        {   // merge adjacent pairs of chunks to and from temp buffer
        cliext::_XChunked_merge(_First, _Last, _Tempbuf._Init(),
            _Chunk, _Count);
        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<

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

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

inline

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

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

_BidIt3 _Merge_backward ( _BidIt1  _First1, _BidIt1  _Last1, _BidIt2  _First2, _BidIt2  _Last2, _BidIt3  _Dest, _Pr  _Pred  )

inline

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

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

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

template<class _FwdIt , class _Pr >

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

inline

template<class _FwdIt , class _Pr >

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

inline

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

    {   // find first satisfying _Pred with successor

template<class _BidIt , class _Pr >

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

inline

template<class _InIt , class _Pr >

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

inline

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

template<class _RanIt , class _Pr >

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

inline

    {   // order Nth element, using _Pred
    _STLCLRDB_RANGE(_First, _Nth);

template<class _RanIt , class _Ty , class _Pr >

void _Partial_sort ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, _Pr  _Pred, _Ty *    )

inline

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

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

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

_RanIt _Partial_sort_copy ( _InIt  _First1, _InIt  _Last1, _RanIt  _First2, _RanIt  _Last2, _Pr  _Pred, _Diff *  , _Ty *    )

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

template<class _FwdIt , class _Pr >

_FwdIt _Partition ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred, forward_iterator_tag    )

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),
        _Unchecked(_Dest), _Pred));

template<class _BidIt , class _Pr >

_BidIt _Partition ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred, bidirectional_iterator_tag    )

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

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

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

            for (; _Oldfirst1 != _First1 && _First1[-1] == _Val; --_First1)
                --_Count1;  // back up over any skipped prefix

            if (_Count1 <= _Last1 - _Mid1)

template<class _FwdIt , class _Diff , class _Pr >

_FwdIt _Partition_point ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred, _Diff *    )

inline

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

template<class _FwdIt1,
    class _FwdIt2> inline
    _FwdIt2 swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2)
    {   // swap [_First1, _Last1) with [_First2, ...)
    _STLCLRDB_RANGE(_First1, _Last1);
    return (cliext::swap_ranges_unchecked(

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

void _Pop_heap ( _RanIt  _First, _RanIt  _Last, _RanIt  _Dest, _Ty &&  _Val, _Pr  _Pred, _Diff *    )

inline

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

template<class _RanIt , class _Pr >

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

inline

template<class _RanIt , class _Ty , class _Pr >

void _Pop_heap_0 ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred, _Ty *    )

inline

            {   // right larger, cut it in half and partition left to match

template<class _Ty >

_Post_equal_to_ ( ) const

inline

template<class _Ty >

_Post_equal_to_ ( ) const

inline

template<class _BidIt , class _Pr >

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

inline

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

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

inline

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

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

void _Push_heap_0 ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred, _Diff *  , _Ty *    )

inline

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

template<class _RanIt , class _Fn1 , class _Diff >

void _Random_shuffle ( _RanIt  _First, _RanIt  _Last, _Fn1 &  _Func, _Diff *    )

inline

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

template<class _FwdIt , class _Ty >

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

inline

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

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

template<class _InIt , class _OutIt , class _Ty >

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

inline

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

template<class _InIt , class _OutIt , class _Pr >

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

inline

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

template<class _FwdIt , class _Pr >

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

inline

    {   // order heap by repeatedly popping, using operator<

template<class _FwdIt , class _Ty >

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

inline

    {   // copy rotating [_First, _Last)

template<class _InIt , class _OutIt , class _Ty >

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

inline

    {   // shuffle [_First, _Last)

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

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

inline

template<class _FwdIt , class _Pr , class _Ty >

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

inline

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

template<class _BidIt , class _OutIt >

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

inline

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

template<class _FwdIt1 , class _FwdIt2 , class _Diff1 , class _Diff2 , class _Pr >

_FwdIt1 _Search ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr  _Pred, _Diff1 *  , _Diff2 *    )

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
    _OutIt transform_unchecked(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
    {   // transform [_First1, _Last1) and [_First2, _Last2) with _Func

template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >

_FwdIt1 _Search_n ( _FwdIt1  _First1, _FwdIt1  _Last1, _Diff2  _Count, const _Ty &  _Val, _Pr  _Pred, forward_iterator_tag    )

inline

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

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

template<class _FwdIt,
    class _Pr,

template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >

_FwdIt1 _Search_n ( _FwdIt1  _First1, _FwdIt1  _Last1, _Diff2  _Count, const _Ty &  _Val, _Pr  _Pred, random_access_iterator_tag    )

inline

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

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

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

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

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

        // TEMPLATE FUNCTION max_element
template<class _FwdIt> inline
    _FwdIt max_element_unchecked(_FwdIt _First, _FwdIt _Last)
    {   // find largest element, using operator<

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

    {   // take set [_First2, _Last2) from [_First1, _Last1), using operator<
    for (; _First1 != _Last1 && _First2 != _Last2; )
        if (_STLCLRDB_LT(*_First1, *_First2))
            *_Dest++ = *_First1, ++_First1;
        else if (*_First2 < *_First1)
            ++_First2;

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

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

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

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

template<class _InIt1,
    class _InIt2,
    class _OutIt> inline
    _OutIt set_union(_InIt1 _First1, _InIt1 _Last1,
        _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
    {   // OR sets [_First1, _Last1) and [_First2, _Last2), using operator<

template<class _RanIt , class _Diff , class _Pr >

void _Sort ( _RanIt  _First, _RanIt  _Last, _Diff  _Ideal, _Pr  _Pred  )

inline

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

        cliext::_XBuffered_merge(_First, _Mid, _Last,
            _Count2, _Count - _Count2, _Tempbuf, _Pred);    // merge halves
        }
    }

#if __cplusplus_cli
template<class _BidIt,
    class _Diff,
    class _Ty,
    class _Pr> inline
    void _XStable_sort(_BidIt _First, _BidIt _Last, _Diff _Count,
        _Temp_gc_iterator<_Ty> _Tempbuf, _Pr _Pred)
    {   // 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;

template<class _RanIt , class _Pr >

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

inline

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

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

inline

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

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

_BidIt _Stable_partition ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred, _Diff *  , _Ty *    )

inline

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

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

void _Stable_sort ( _BidIt  _First, _BidIt  _Last, _Diff  _Count, _Temp_iterator< _Ty > &  _Tempbuf, _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(
        _Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last), _Pred);
    }

        // TEMPLATE FUNCTION partial_sort_copy
template<class _InIt,
    class _RanIt> inline
    _RanIt partial_sort_copy_unchecked(_InIt _First1, _InIt _Last1,

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

void _Stable_sort ( _BidIt  _First, _BidIt  _Last, _Diff *  , _Ty *  , _Pr  _Pred  )

inline

        {   // copy and sort nontrivial
        _RanIt _Mid2 = _First2;

        for (; _First1 != _Last1 && _Mid2 != _Last2; ++_First1, ++_Mid2)

template<class _FwdIt1 , class _FwdIt2 >

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

inline

    {   // remove each matching _Val
    _STLCLRDB_RANGE(_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, input iterators
    typedef iterator_traits<_InIt>::value_type _Ty;

    _Ty _Val = *_First;

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, random-access iterators
    return (_Unique_copy(_First, _Last, _Dest, _Pred,
        forward_iterator_tag()));
    }

template<class _RanIt , class _Pr >

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

#if __cplusplus_cli
template<class _BidIt,
    class _Diff,
    class _Ty,
    class _Pr> inline
    void _XBuffered_merge_sort(_BidIt _First, _BidIt _Last, _Diff _Count,
        _Temp_gc_iterator<_Ty> _Tempbuf, _Pr _Pred)
    {   // sort using temp buffer for merges, using _Pred
    _BidIt _Mid = _First;
    for (_Diff _Nleft = _Count; _ISort::_Max <= _Nleft; _Nleft -= _ISort::_Max)
        {   // sort chunks
        _BidIt _Midn = _Mid;
        cliext::advance(_Midn, (int)_ISort::_Max);

        cliext::_XInsertion_sort(_Mid, _Midn, _Pred);
        _Mid = _Midn;
        }
    cliext::_XInsertion_sort(_Mid, _Last, _Pred);   // 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, _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
        {   // sort halves and merge
        _Diff _Count2 = (_Count + 1) / 2;
        _BidIt _Mid = _First;
        cliext::advance(_Mid, _Count2);

        if (_Count2 <= _Tempbuf._Maxlen())

template<class _FwdIt , class _Pr >

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

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

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

_OutIt _Unique_copy ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr  _Pred, _Ty *    )

inline

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

template<class _InIt , class _OutIt , class _Pr >

_OutIt _Unique_copy ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr  _Pred, input_iterator_tag    )

inline

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

template<class _FwdIt , class _OutIt , class _Pr >

_OutIt _Unique_copy ( _FwdIt  _First, _FwdIt  _Last, _OutIt  _Dest, _Pr  _Pred, forward_iterator_tag    )

inline

    {   // find first element not before _Val, using _Pred

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

_FwdIt _Upper_bound ( _FwdIt  _First, _FwdIt  _Last, const _Ty &  _Val, _Pr  _Pred, _Diff *    )

inline

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

template<class _RanIt> inline
    _PAIR_TYPE(_RanIt) _XUnguarded_partition(_RanIt _First, _RanIt _Last)
    {   // partition [_First, _Last), using operator<

template<class _FwdIt , class _Pr >

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

inline

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

template<class _FwdIt >

_FwdIt adjacent_find ( _FwdIt  _First, _FwdIt  _Last  )

inline

    {   // find first satisfying _Pred

template<class _InIt , class _Pr >

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

inline

        {   // room for match, try it

template<class _InIt , class _Pr >

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

inline

    {   // find first [_First2, _Last2) satisfying _Pred
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_RANGE(_First2, _Last2);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::search_unchecked(_Unchecked(_First1), _Unchecked(_Last1),

template<class _FwdIt , class _Ty , class _Pr >

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

inline

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

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

template<class _FwdIt , class _Ty >

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

inline

    {   // insertion sort [_First, _Last), using _Pred

template<class _InIt , class _OutIt , class _Pr >

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

inline

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

template<class _InIt , class _Pr >

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

inline

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

template<class _FwdIt , class _Ty , class _Pr >

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

inline

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

template<class _FwdIt , class _Ty >

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

inline

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

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

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

template<class _InIt,
    class _OutIt,

template<class _FwdIt1 , class _FwdIt2 >

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

inline

    {   // copy omitting each element satisfying _Pred

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

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

template<class _FwdIt1 , class _FwdIt2 >

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

inline

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

template<class _InIt , class _Pr >

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

inline

    {   // find first char that matches _Val

template<class _InIt , class _Pr >

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

inline

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

    _FwdIt1 _Oldfirst1 = _First1;

template<class _InIt , class _Fn1 >

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

inline

    {   // find first matching _Val

template<class _FwdIt , class _Fn0 >

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

inline

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

template<class _OutIt , class _Diff , class _Fn0 >

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

inline

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

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

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

template<class _InIt1 , class _InIt2 >

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

inline

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

template<class _BidIt , class _Pr >

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

inline

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

        cliext::_XBuffered_merge(_First, _Mid, _Last,
            _Count2, _Count - _Count2, _Tempbuf);   // merge sorted halves
        }

template<class _BidIt >

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

inline

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

template<class _RanIt , class _Pr >

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

template<class _RanIt >

bool is_heap	(	_RanIt	_First,
		_RanIt	_Last
	)

template<class _RanIt , class _Pr >

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

template<class _RanIt >

_RanIt is_heap_until	(	_RanIt	_First,
		_RanIt	_Last
	)

template<class _InIt , class _Pr >

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

inline

    {   // swap *_Left and *_Right

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

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

template<class _FwdIt , class _Ty >

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

inline

    {   // sort median of three elements to middle

template<class _RanIt , class _Pr >

void make_heap ( _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,

template<class _RanIt >

void make_heap ( _RanIt  _First, _RanIt  _Last  )

inline

            {   // right larger, cut it in half and partition left to match
            _Count1n = 0, _Count2n = _Count2 / 2;
            _Lastn = _Mid;

template<class _Ty >

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

inline

template<class _Ty , class _Pr >

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

inline

template<class _Ty , class _Pr >

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

inline

template<class _FwdIt , class _Pr >

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

inline

template<class _FwdIt >

_FwdIt max_element ( _FwdIt  _First, _FwdIt  _Last  )

inline

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
    if (40 < _Last - _First)
        {   // median of nine

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

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

template<class _Ty >

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

inline

template<class _Ty , class _Pr >

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

inline

template<class _Ty , class _Pr >

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

inline

template<class _FwdIt , class _Pr >

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

inline

template<class _FwdIt >

_FwdIt min_element ( _FwdIt  _First, _FwdIt  _Last  )

inline

template<class _Ty >

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

inline

template<class _Ty >

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

inline

template<class _Ty , class _Pr >

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

inline

template<class _Ty , class _Pr >

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

inline

template<class _FwdIt , class _Pr >

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

inline

template<class _FwdIt >

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

inline

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

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

template<class _InIt1 , class _InIt2 >

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

inline

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

template<class _BidIt , class _Pr >

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

inline

template<class _BidIt >

bool next_permutation ( _BidIt  _First, _BidIt  _Last  )

inline

template<class _InIt , class _Pr >

bool none_of ( _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)

template<class _RanIt , class _Pr >

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

inline

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

template<class _RanIt >

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

inline

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

template<class _RanIt , class _Pr >

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

inline

template<class _RanIt >

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

inline

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

template<class _InIt , class _RanIt , class _Pr >

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

inline

    {   // order Nth element, using operator<
    _STLCLRDB_RANGE(_First, _Nth);
    _STLCLRDB_RANGE(_Nth, _Last);

template<class _InIt , class _RanIt >

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

inline

    {   // order Nth element, using _Pred

template<class _FwdIt , class _Pr >

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

inline

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

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

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

template<class _FwdIt , class _Pr >

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

inline

    {   // transform [_First, _Last) with _Func

template<class _RanIt , class _Pr >

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

inline

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

template<class _RanIt >

void pop_heap ( _RanIt  _First, _RanIt  _Last  )

inline

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

template<class _BidIt , class _Pr >

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

inline

template<class _BidIt >

bool prev_permutation ( _BidIt  _First, _BidIt  _Last  )

inline

template<class _RanIt , class _Pr >

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

void push_heap ( _RanIt  _First, _RanIt  _Last  )

inline

    {   // merge backwards to _Dest, using _Pred

template<class _RanIt , class _Fn1 >

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

inline

    {   // copy merging ranges, both using operator<

template<class _RanIt >

void random_shuffle ( _RanIt  _First, _RanIt  _Last  )

inline

template<class _FwdIt , class _Ty >

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

inline

    {   // make [_First, _Last) into a heap, using _Pred

template<class _InIt , class _OutIt , class _Ty >

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

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 _InIt , class _OutIt , class _Pr >

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

inline

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

template<class _FwdIt , class _Pr >

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

inline

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

template<class _FwdIt , class _Ty >

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

inline

    {   /* compute pseudo-random value */

template<class _InIt , class _OutIt , class _Ty >

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

inline

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

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

    {   // partition preserving order of equivalents, using _Pred

template<class _FwdIt , class _Pr , class _Ty >

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

inline

            {   // assume unsigned long big enough for _Diff count
            unsigned long _Rm = _RANDOM_MAX;
            unsigned long _Rn = _Rand() & _RANDOM_MAX;

template<class _BidIt , class _OutIt >

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

inline

            {   // range straddles mid, find each end and return

template<class _FwdIt , class _OutIt >

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

inline

    {   // test if _Val equivalent to some element, using operator<
    _First = cliext::lower_bound_unchecked(_First, _Last, _Val);
    return (_First != _Last && !(_Val < *_First));
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

    {   // transform [_First1, _Last1) and [_First2, _Last2) with _Func
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_POINTER(_First2);
    _STLCLRDB_POINTER(_Dest);

template<class _FwdIt1 , class _FwdIt2 >

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

inline

    {   // replace each matching _Oldval with _Newval

template<class _FwdIt1 , class _Diff2 , class _Ty , class _Pr >

_FwdIt1 search_n ( _FwdIt1  _First1, _FwdIt1  _Last1, _Diff2  _Count, const _Ty &  _Val, _Pr  _Pred  )

inline

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

template<class _FwdIt1 , class _Diff2 , class _Ty >

_FwdIt1 search_n ( _FwdIt1  _First1, _FwdIt1  _Last1, _Diff2  _Count, const _Ty &  _Val  )

inline

    {   // replace [_First, _Last) with _Func()
    for (; _First != _Last; ++_First)
        *_First = _Func();

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

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

inline

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

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

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

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

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

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

    {   // XOR sets [_First1, _Last1) and [_First2, _Last2), 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

            {   // pure descending, flip all
            cliext::reverse(_First, _Last);
            return (false);
            }

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

            {   // pure ascending, flip all
            cliext::reverse(_First, _Last);
            return (false);

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

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

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

    {   // AND sets [_First1, _Last1) and [_First2, _Last2), using _Pred
    for (; _First1 != _Last1 && _First2 != _Last2; )
        if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
            ++_First1;

template<class _RanIt , class _Urng >

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

inline

    {   // copy merging ranges, both using operator<

template<class _RanIt , class _Pr >

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

template<class _RanIt >

void sort ( _RanIt  _First, _RanIt  _Last  )

inline

template<class _RanIt , class _Pr >

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

inline

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

template<class _RanIt >

void sort_heap ( _RanIt  _First, _RanIt  _Last  )

inline

        {   // merge nontrivial sequence
        _Diff _Count1 = 0;

template<class _BidIt , class _Pr >

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

inline

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

template<class _BidIt , class _Pr >

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

inline

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

template<class _BidIt >

void stable_sort ( _BidIt  _First, _BidIt  _Last  )

inline

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

template<class _FwdIt1 , class _FwdIt2 >

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

inline

    {   // remove each satisfying _Pred

template<class _InIt , class _OutIt , class _Fn1 >

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

inline

    {   // copy compressing pairs that match, forward iterators
    _FwdIt _Firstb = _First;

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

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

inline

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

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

template<class _FwdIt , class _Pr >

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

inline

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

template<class _FwdIt >

_FwdIt unique ( _FwdIt  _First, _FwdIt  _Last  )

inline

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

template<class _InIt , class _OutIt , class _Pr >

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

inline

    {   // find first element that _Val is before, using operator<

template<class _InIt , class _OutIt >

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

inline

    {   // find first element that _Val is before, using _Pred

template<class _FwdIt , class _Ty , class _Pr >

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

inline

        {   // partition

template<class _FwdIt , class _Ty >

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

inline

        {   // partition
        for (; _Gfirst < _Last; ++_Gfirst)

Variable Documentation

_STD_BEGIN const int _ISORT_MAX = 32

const _Ty & _Right

Initial value:

{   
    return (_DEBUG_LT(_Left, _Right) ? _Right : _Left)

const _Ty& _Right

Initial value:

{   
    return (_DEBUG_LT(_Right, _Left) ? _Right : _Left)

---

Generated on Sun Jul 23 2017 09:59:59 for STLdoc by   1.8.8