cliext Namespace Reference

Namespaces
	impl

Classes
class	_Binary_fun
class	_Binary_fun_noreturn
class	_Cont_make_value
class	_Cont_make_value< _Value_t, true >
class	_Container_traits
class	_Container_traits< _Cont_t^>
class	_Dehandle
class	_Dehandle< _Value_t^>
class	_Fix_handle
class	_Fix_handle< _To_t, _From_t^>
class	_Fix_handle< _To_t^, _From_t >
class	_Fix_handle< _To_t^, _From_t^>
class	_Generic_type
class	_Generic_type< _Value_t, false >
class	_Generic_type< _Value_t, true >
class	_Int_iterator_tag
class	_ISort
class	_Map_iter_cat
class	_Map_iter_cat< std::bidirectional_iterator_tag >
class	_Map_iter_cat< std::forward_iterator_tag >
class	_Map_iter_cat< std::input_iterator_tag >
class	_Map_iter_cat< std::output_iterator_tag >
class	_Map_iter_cat< std::random_access_iterator_tag >
class	_Pick_pair
class	_Pick_pair< false, _Value1_t, _Value2_t >
class	_Pick_pair< true, _Value1_t, _Value2_t >
class	_Pick_tbuf
class	_Pick_tbuf< false, _Value_t >
class	_Pick_tbuf< true, _Value_t >
class	_Temp_gc_iterator
class	_Temp_iterator
class	_Unary_fun
class	_Unary_fun_noreturn
class	ArrayContainer
class	BCL_iterator
class	BCL_reference
class	BCL_reference_base
class	BCL_reference_base< _Cont_t, true >
class	bidirectional_iterator_tag
class	BidirectionalIterator
class	binary_function
class	binary_negate
class	binder1st
class	binder2nd
class	collection_adapter
class	collection_adapter< System::Collections::Generic::ICollection< _Value_t > >
class	collection_adapter< System::Collections::Generic::IDictionary< _Key_t, _Mapped_t > >
class	collection_adapter< System::Collections::Generic::IEnumerable< _Value_t > >
class	collection_adapter< System::Collections::Generic::IList< _Value_t > >
class	collection_adapter< System::Collections::ICollection >
class	collection_adapter< System::Collections::IDictionary >
class	collection_adapter< System::Collections::IEnumerable >
class	collection_adapter< System::Collections::IList >
class	comparer_less
class	ConstBidirectionalIterator
class	ConstRandomAccessIterator
class	ConstUncheckedBidirectionalIterator
class	ConstUncheckedRandomAccessIterator
class	deque
class	divides
class	Enum_iterator
class	equal_to
class	forward_iterator_tag
class	greater
class	greater_equal
class	hash_map
class	hash_multimap
class	hash_multiset
class	hash_set
class	input_iterator_tag
class	is_handle
class	is_handle< _Value_t^>
class	iterator_traits
class	iterator_traits< __int64 >
class	iterator_traits< _Iter_t^>
class	iterator_traits< _STLCLR Generic::ConstContainerBidirectionalIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::ConstContainerRandomAccessIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::ConstReverseBidirectionalIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::ConstReverseRandomAccessIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::ContainerBidirectionalIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::ContainerRandomAccessIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::IBidirectionalIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::IForwardIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::IInputIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::IOutputIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::IRandomAccessIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::ReverseBidirectionalIterator< _Ty > >
class	iterator_traits< _STLCLR Generic::ReverseRandomAccessIterator< _Ty > >
class	iterator_traits< _Ty * >
class	iterator_traits< bool >
class	iterator_traits< char >
class	iterator_traits< const _Ty * >
class	iterator_traits< int >
class	iterator_traits< long >
class	iterator_traits< short >
class	iterator_traits< signed char >
class	iterator_traits< unsigned __int64 >
class	iterator_traits< unsigned char >
class	iterator_traits< unsigned int >
class	iterator_traits< unsigned long >
class	iterator_traits< unsigned short >
class	iterator_traits< wchar_t >
class	less
class	less_equal
class	light_pair
class	list
class	logical_and
class	logical_not
class	logical_or
class	map
class	minus
class	modulus
class	multimap
class	multiplies
class	multiset
class	negate
class	not_equal_to
class	output_iterator_tag
class	pair
class	plus
class	priority_queue
class	queue
class	random_access_iterator_tag
class	RandomAccessIterator
class	range_adapter
class	ref_binary_negate
class	ref_binder1st
class	ref_binder2nd
class	ref_divides
class	ref_equal_to
class	ref_greater
class	ref_greater_equal
class	ref_less
class	ref_less_equal
class	ref_logical_and
class	ref_logical_not
class	ref_logical_or
class	ref_minus
class	ref_modulus
class	ref_multiplies
class	ref_negate
class	ref_not_equal_to
class	ref_plus
class	ref_unary_negate
class	ReverseBidirectionalIterator
class	ReverseRandomAccessIterator
class	select_pair
class	select_pair< _Value1_t, _Value2_t, false >
class	set
class	stack
class	unary_function
class	unary_negate
class	UncheckedBCL_iterator
class	UncheckedBidirectionalIterator
class	UncheckedRandomAccessIterator
class	vector

Functions
template<typename _Iter_t >
range_adapter< _Iter_t >	make_collection (_Iter_t _First, _Iter_t _Last)
template<class _InIt , class _Fn1 >
_Fn1	for_each_unchecked (_InIt _First, _InIt _Last, _Fn1 _Func)
template<class _InIt , class _Fn1 >
_Fn1	for_each (_InIt _First, _InIt _Last, _Fn1 _Func)
template<class _InIt , class _Ty >
_InIt	find_unchecked (_InIt _First, _InIt _Last, const _Ty%_Val)
template<class _InIt , class _Ty >
_InIt	find (_InIt _First, _InIt _Last, const _Ty%_Val)
const char *	find (const char *_First, const char *_Last, int _Val)
const signed char *	find (const signed char *_First, const signed char *_Last, int _Val)
const unsigned char *	find (const unsigned char *_First, const unsigned char *_Last, int _Val)
template<class _InIt , class _Pr >
_InIt	find_if_unchecked (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _InIt , class _Pr >
_InIt	find_if (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	adjacent_find_unchecked (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt >
_FwdIt	adjacent_find (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	adjacent_find_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	adjacent_find (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _InIt , class _Ty >
iterator_traits< _InIt >::difference_type	count_unchecked (_InIt _First, _InIt _Last, const _Ty%_Val)
template<class _InIt , class _Ty >
iterator_traits< _InIt >::difference_type	count (_InIt _First, _InIt _Last, const _Ty%_Val)
template<class _InIt , class _Pr >
iterator_traits< _InIt >::difference_type	count_if_unchecked (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _InIt , class _Pr >
iterator_traits< _InIt >::difference_type	count_if (_InIt _First, _InIt _Last, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	search_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	search (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	search_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	search (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1	_Search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, forward_iterator_tag)
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1	_Search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val, random_access_iterator_tag)
template<class _FwdIt1 , class _Diff2 , class _Ty >
_FwdIt1	search_n (_FwdIt1 _First1, _FwdIt1 _Last1, _Diff2 _Count, const _Ty%_Val)
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 _FwdIt2 >
_FwdIt1	find_end_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
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_end_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	find_end (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	find_first_of_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt1	find_first_of (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	find_first_of_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 , class _Pr >
_FwdIt1	find_first_of (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred)
template<class _FwdIt1 , class _FwdIt2 >
void	iter_swap (_FwdIt1 _Left, _FwdIt2 _Right)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2	swap_ranges_unchecked (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
template<class _FwdIt1 , class _FwdIt2 >
_FwdIt2	swap_ranges (_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2)
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt	transform_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
template<class _InIt , class _OutIt , class _Fn1 >
_OutIt	transform (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn1 _Func)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	transform_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >
_OutIt	transform (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
template<class _FwdIt , class _Ty >
void	replace_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Oldval, const _Ty%_Newval)
template<class _FwdIt , class _Ty >
void	replace (_FwdIt _First, _FwdIt _Last, const _Ty%_Oldval, const _Ty%_Newval)
template<class _FwdIt , class _Pr , class _Ty >
void	replace_if_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty%_Val)
template<class _FwdIt , class _Pr , class _Ty >
void	replace_if (_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty%_Val)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	replace_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Oldval, const _Ty%_Newval)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	replace_copy (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Oldval, const _Ty%_Newval)
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt	replace_copy_if_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty%_Val)
template<class _InIt , class _OutIt , class _Pr , class _Ty >
_OutIt	replace_copy_if (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty%_Val)
template<class _FwdIt , class _Fn0 >
void	generate_unchecked (_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
template<class _FwdIt , class _Fn0 >
void	generate (_FwdIt _First, _FwdIt _Last, _Fn0 _Func)
template<class _OutIt , class _Diff , class _Fn0 >
void	generate_n_unchecked (_OutIt _Dest, _Diff _Count, _Fn0 _Func)
template<class _OutIt , class _Diff , class _Fn0 >
void	generate_n (_OutIt _Dest, _Diff _Count, _Fn0 _Func)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	remove_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Val)
template<class _InIt , class _OutIt , class _Ty >
_OutIt	remove_copy (_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty%_Val)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	remove_copy_if_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	remove_copy_if (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _FwdIt , class _Ty >
_FwdIt	remove_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Ty >
_FwdIt	remove (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Pr >
_FwdIt	remove_if_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	remove_if (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	unique_unchecked (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt >
_FwdIt	unique (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	unique_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	unique (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _InIt , class _OutIt >
_OutIt	_Unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, input_iterator_tag)
template<class _FwdIt , class _OutIt >
_OutIt	_Unique_copy (_FwdIt _First, _FwdIt _Last, _OutIt _Dest, forward_iterator_tag)
template<class _BidIt , class _OutIt >
_OutIt	_Unique_copy (_BidIt _First, _BidIt _Last, _OutIt _Dest, bidirectional_iterator_tag)
template<class _RanIt , class _OutIt >
_OutIt	_Unique_copy (_RanIt _First, _RanIt _Last, _OutIt _Dest, random_access_iterator_tag)
template<class _InIt , class _OutIt >
_OutIt	unique_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest)
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 _BidIt , class _OutIt , class _Pr >
_OutIt	_Unique_copy (_BidIt _First, _BidIt _Last, _OutIt _Dest, _Pr _Pred, bidirectional_iterator_tag)
template<class _RanIt , class _OutIt , class _Pr >
_OutIt	_Unique_copy (_RanIt _First, _RanIt _Last, _OutIt _Dest, _Pr _Pred, random_access_iterator_tag)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	unique_copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _InIt , class _OutIt , class _Pr >
_OutIt	unique_copy (_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred)
template<class _BidIt >
void	_Reverse (_BidIt _First, _BidIt _Last, bidirectional_iterator_tag)
template<class _RanIt >
void	_Reverse (_RanIt _First, _RanIt _Last, random_access_iterator_tag)
template<class _BidIt >
void	reverse_unchecked (_BidIt _First, _BidIt _Last)
template<class _BidIt >
void	reverse (_BidIt _First, _BidIt _Last)
template<class _BidIt , class _OutIt >
_OutIt	reverse_copy_unchecked (_BidIt _First, _BidIt _Last, _OutIt _Dest)
template<class _BidIt , class _OutIt >
_OutIt	reverse_copy (_BidIt _First, _BidIt _Last, _OutIt _Dest)
template<class _FwdIt >
void	_Rotate (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, forward_iterator_tag)
template<class _BidIt >
void	_Rotate (_BidIt _First, _BidIt _Mid, _BidIt _Last, bidirectional_iterator_tag)
template<class _RanIt >
void	_Rotate (_RanIt _First, _RanIt _Mid, _RanIt _Last, random_access_iterator_tag)
template<class _FwdIt >
void	rotate_unchecked (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
template<class _FwdIt >
void	rotate (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
template<class _FwdIt , class _OutIt >
_OutIt	rotate_copy_unchecked (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
template<class _FwdIt , class _OutIt >
_OutIt	rotate_copy (_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest)
int	_Rand (void)
template<class _RanIt >
void	random_shuffle_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	random_shuffle (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Fn1 >
void	random_shuffle_unchecked (_RanIt _First, _RanIt _Last, _Fn1%_Func)
template<class _RanIt , class _Fn1 >
void	random_shuffle (_RanIt _First, _RanIt _Last, _Fn1%_Func)
template<class _BidIt , class _Pr >
_BidIt	partition_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
_BidIt	partition (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr , class _Diff , class _Ty >
_BidIt	_XStable_partition (_BidIt _First, _BidIt _Last, _Pr _Pred, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
template<class _BidIt , class _Pr >
_BidIt	stable_partition_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
_BidIt	stable_partition (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _RanIt , class _Diff , class _Ty >
void	_XPush_heap (_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val)
template<class _RanIt >
void	push_heap_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	push_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void	_XPush_heap (_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val, _Pr _Pred)
template<class _RanIt , class _Pr >
void	push_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	push_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Diff , class _Ty >
void	_XAdjust_heap (_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
template<class _RanIt , class _Ty >
void	_XPop_heap (_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty _Val)
template<class _RanIt >
void	pop_heap_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	pop_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Diff , class _Ty , class _Pr >
void	_XAdjust_heap (_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val, _Pr _Pred)
template<class _RanIt , class _Ty , class _Pr >
void	_XPop_heap (_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty _Val, _Pr _Pred)
template<class _RanIt , class _Pr >
void	pop_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	pop_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	make_heap_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	make_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Pr >
void	make_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	make_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt >
void	sort_heap_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	sort_heap (_RanIt _First, _RanIt _Last)
template<class _RanIt , class _Pr >
void	sort_heap_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	sort_heap (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _FwdIt , class _Ty >
_FwdIt	lower_bound_unchecked (_FwdIt _First, _FwdIt _Last, _Ty%_Val)
template<class _FwdIt , class _Ty >
_FwdIt	lower_bound (_FwdIt _First, _FwdIt _Last, _Ty%_Val)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	lower_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	lower_bound (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt , class _Ty >
_FwdIt	upper_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Ty >
_FwdIt	upper_bound (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	upper_bound_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt , class _Ty , class _Pr >
_FwdIt	upper_bound (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt , class _Ty >
	_PAIR_TYPE (_FwdIt) equal_range_unchecked(_FwdIt _First
	_Iter_distance (_First, _Last, _Count)
	for (;0< _Count;)
	return (_PAIR_TYPE(_FwdIt)(_First, _First))
	return (cliext::equal_range_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val))
template<class _FwdIt , class _Ty , class _Pr >
	_PAIR_TYPE (_FwdIt) equal_range_unchecked(_FwdIt _First
	return (cliext::equal_range_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val, _Pred))
template<class _FwdIt , class _Ty >
bool	binary_search_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Ty >
bool	binary_search (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _FwdIt , class _Ty , class _Pr >
bool	binary_search_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _FwdIt , class _Ty , class _Pr >
bool	binary_search (_FwdIt _First, _FwdIt _Last, const _Ty%_Val, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	merge_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	merge (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	merge_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	merge (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty >
_BidIt	_XBuffered_rotate (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
template<class _BidIt1 , class _BidIt2 , class _BidIt3 >
_BidIt3	_XMerge_backward (_BidIt1 _First1, _BidIt1 _Last1, _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest)
template<class _BidIt , class _Diff , class _Ty >
void	_XBuffered_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf)
template<class _BidIt >
void	inplace_merge_unchecked (_BidIt _First, _BidIt _Mid, _BidIt _Last)
template<class _BidIt >
void	inplace_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last)
template<class _BidIt1 , class _BidIt2 , class _BidIt3 , class _Pr >
_BidIt3	_XMerge_backward (_BidIt1 _First1, _BidIt1 _Last1, _BidIt2 _First2, _BidIt2 _Last2, _BidIt3 _Dest, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	_XBuffered_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Diff _Count1, _Diff _Count2, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
template<class _BidIt , class _Pr >
void	inplace_merge_unchecked (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
void	inplace_merge (_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred)
template<class _BidIt >
void	_XInsertion_sort (_BidIt _First, _BidIt _Last)
template<class _RanIt >
void	_XMed3 (_RanIt _First, _RanIt _Mid, _RanIt _Last)
template<class _RanIt >
void	_XMedian (_RanIt _First, _RanIt _Mid, _RanIt _Last)
template<class _RanIt >
	_PAIR_TYPE (_RanIt) _XUnguarded_partition(_RanIt _First
	while (_First< _Pfirst &&!_STLCLRDB_LT(*(_Pfirst-1),*_Pfirst)&&!(*_Pfirst< *(_Pfirst-1)))--_Pfirst
	for (;;)
template<class _RanIt , class _Diff >
void	_XSort (_RanIt _First, _RanIt _Last, _Diff _Ideal)
template<class _RanIt >
void	sort_unchecked (_RanIt _First, _RanIt _Last)
template<class _RanIt >
void	sort (_RanIt _First, _RanIt _Last)
template<class _BidIt , class _Pr >
void	_XInsertion_sort (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	_XMed3 (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	_XMedian (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
	_PAIR_TYPE (_RanIt) _XUnguarded_partition(_RanIt _First
template<class _RanIt , class _Diff , class _Pr >
void	_XSort (_RanIt _First, _RanIt _Last, _Diff _Ideal, _Pr _Pred)
template<class _RanIt , class _Pr >
void	sort_unchecked (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	sort (_RanIt _First, _RanIt _Last, _Pr _Pred)
template<class _BidIt , class _OutIt , class _Diff >
void	_XChunked_merge (_BidIt _First, _BidIt _Last, _OutIt _Dest, _Diff _Chunk, _Diff _Count)
template<class _BidIt , class _Diff , class _Ty >
void	_XBuffered_merge_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
template<class _BidIt , class _Diff , class _Ty >
void	_XStable_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf)
template<class _BidIt >
void	stable_sort_unchecked (_BidIt _First, _BidIt _Last)
template<class _BidIt >
void	stable_sort (_BidIt _First, _BidIt _Last)
template<class _BidIt , class _OutIt , class _Diff , class _Pr >
void	_XChunked_merge (_BidIt _First, _BidIt _Last, _OutIt _Dest, _Diff _Chunk, _Diff _Count, _Pr _Pred)
template<class _BidIt , class _Diff , class _Ty , class _Pr >
void	_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	_XStable_sort (_BidIt _First, _BidIt _Last, _Diff _Count, _Temp_iterator< _Ty > _Tempbuf, _Pr _Pred)
template<class _BidIt , class _Pr >
void	stable_sort_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
void	stable_sort (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _RanIt >
void	partial_sort_unchecked (_RanIt _First, _RanIt _Mid, _RanIt _Last)
template<class _RanIt >
void	partial_sort (_RanIt _First, _RanIt _Mid, _RanIt _Last)
template<class _RanIt , class _Pr >
void	partial_sort_unchecked (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	partial_sort (_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred)
template<class _InIt , class _RanIt >
_RanIt	partial_sort_copy_unchecked (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2)
template<class _InIt , class _RanIt >
_RanIt	partial_sort_copy (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2)
template<class _InIt , class _RanIt , class _Pr >
_RanIt	partial_sort_copy_unchecked (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred)
template<class _InIt , class _RanIt , class _Pr >
_RanIt	partial_sort_copy (_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred)
template<class _RanIt >
void	nth_element_unchecked (_RanIt _First, _RanIt _Nth, _RanIt _Last)
template<class _RanIt >
void	nth_element (_RanIt _First, _RanIt _Nth, _RanIt _Last)
template<class _RanIt , class _Pr >
void	nth_element_unchecked (_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred)
template<class _RanIt , class _Pr >
void	nth_element (_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred)
template<class _InIt1 , class _InIt2 >
bool	includes_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
template<class _InIt1 , class _InIt2 >
bool	includes (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	includes_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	includes (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	set_union_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
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_union_unchecked (_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_intersection_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
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_intersection_unchecked (_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_difference_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
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_difference_unchecked (_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_symmetric_difference_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt >
_OutIt	set_symmetric_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
template<class _InIt1 , class _InIt2 , class _OutIt , class _Pr >
_OutIt	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	set_symmetric_difference (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred)
template<class _FwdIt >
_FwdIt	max_element_unchecked (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt >
_FwdIt	max_element (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	max_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	max_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt >
_FwdIt	min_element_unchecked (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt >
_FwdIt	min_element (_FwdIt _First, _FwdIt _Last)
template<class _FwdIt , class _Pr >
_FwdIt	min_element_unchecked (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _FwdIt , class _Pr >
_FwdIt	min_element (_FwdIt _First, _FwdIt _Last, _Pr _Pred)
template<class _BidIt >
bool	next_permutation_unchecked (_BidIt _First, _BidIt _Last)
template<class _BidIt >
bool	next_permutation (_BidIt _First, _BidIt _Last)
template<class _BidIt , class _Pr >
bool	next_permutation_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
bool	next_permutation (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt >
bool	prev_permutation_unchecked (_BidIt _First, _BidIt _Last)
template<class _BidIt >
bool	prev_permutation (_BidIt _First, _BidIt _Last)
template<class _BidIt , class _Pr >
bool	prev_permutation_unchecked (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<class _BidIt , class _Pr >
bool	prev_permutation (_BidIt _First, _BidIt _Last, _Pr _Pred)
template<typename _Value_t >
bool	operator== (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
template<typename _Value_t >
bool	operator!= (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
template<typename _Value_t >
bool	operator< (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
template<typename _Value_t >
bool	operator>= (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
template<typename _Value_t >
bool	operator> (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
template<typename _Value_t >
bool	operator<= (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
template<typename _Value_t >
void	swap (deque< _Value_t >%_Left, deque< _Value_t >%_Right)
template<typename TArg , typename TResult >
delegate TResult	unary_delegate (TArg)
template<typename TArg >
delegate void	unary_delegate_noreturn (TArg)
template<typename TArg1 , typename TArg2 , typename TResult >
delegate TResult	binary_delegate (TArg1, TArg2)
template<typename TArg1 , typename TArg2 >
delegate void	binary_delegate_noreturn (TArg1, TArg2)
template<typename _Fun_t >
unary_negate< _Fun_t >	not1 (_Fun_t%_Func)
template<typename _Fun_t >
binary_negate< _Fun_t >	not2 (_Fun_t%_Func)
template<typename _Fun_t , typename _Arg_t >
binder1st< _Fun_t >	bind1st (_Fun_t%_Func, _Arg_t _Left)
template<typename _Fun_t , typename _Arg_t >
binder2nd< _Fun_t >	bind2nd (_Fun_t%_Func, _Arg_t _Right)
template<typename _Arg_t >
comparer_less< _Arg_t, System::Collections::Generic::IComparer< _Arg_t > >	make_comparer_less (System::Collections::Generic::IComparer< _Arg_t >^_Comp)
comparer_less< System::Object^, System::Collections::IComparer >	make_comparer_less (System::Collections::IComparer^_Comp)
template<typename _Key_t , typename _Mapped_t >
void	swap (cliext::hash_map< _Key_t, _Mapped_t >%_Left, cliext::hash_map< _Key_t, _Mapped_t >%_Right)
template<typename _Key_t , typename _Mapped_t >
void	swap (cliext::hash_multimap< _Key_t, _Mapped_t >%_Left, cliext::hash_multimap< _Key_t, _Mapped_t >%_Right)
template<typename _Key_t >
void	swap (cliext::hash_set< _Key_t >%_Left, cliext::hash_set< _Key_t >%_Right)
template<typename _Key_t >
void	swap (cliext::hash_multiset< _Key_t >%_Left, cliext::hash_multiset< _Key_t >%_Right)
template<typename _Iter_t >
_Iter_t	_Unchecked (_Iter_t _Iter)
template<typename _Cont_t >
ConstUncheckedBidirectionalIterator< _Cont_t >	_Unchecked (ConstBidirectionalIterator< _Cont_t > _Iter)
template<typename _Cont_t >
UncheckedBidirectionalIterator< _Cont_t >	_Unchecked (BidirectionalIterator< _Cont_t > _Iter)
template<typename _Cont_t >
ReverseBidirectionalIterator< _Cont_t >	_Unchecked (ReverseBidirectionalIterator< _Cont_t > _Iter)
template<typename _Cont_t >
ConstUncheckedRandomAccessIterator< _Cont_t >	_Unchecked (ConstRandomAccessIterator< _Cont_t > _Iter)
template<typename _Cont_t >
UncheckedRandomAccessIterator< _Cont_t >	_Unchecked (RandomAccessIterator< _Cont_t > _Iter)
template<typename _Cont_t >
ReverseRandomAccessIterator< _Cont_t >	_Unchecked (ReverseRandomAccessIterator< _Cont_t > _Iter)
template<typename _Cont_t , bool _Is_ref>
UncheckedBCL_iterator< _Cont_t, _Is_ref >	_Unchecked (BCL_iterator< _Cont_t, _Is_ref > _Iter)
template<typename _Iter_t >
System::Object	_Iter_container (_Iter_t%_Next)
template<typename _Iter_t >
System::Object	_Iter_container (_Iter_t^_Next)
template<typename _Value_t >
bool	operator== (list< _Value_t >%_Left, list< _Value_t >%_Right)
template<typename _Value_t >
bool	operator!= (list< _Value_t >%_Left, list< _Value_t >%_Right)
template<typename _Value_t >
bool	operator< (list< _Value_t >%_Left, list< _Value_t >%_Right)
template<typename _Value_t >
bool	operator>= (list< _Value_t >%_Left, list< _Value_t >%_Right)
template<typename _Value_t >
bool	operator> (list< _Value_t >%_Left, list< _Value_t >%_Right)
template<typename _Value_t >
bool	operator<= (list< _Value_t >%_Left, list< _Value_t >%_Right)
template<typename _Value_t >
void	swap (list< _Value_t >%_Left, list< _Value_t >%_Right)
template<typename _Key_t , typename _Mapped_t >
void	swap (map< _Key_t, _Mapped_t >%_Left, map< _Key_t, _Mapped_t >%_Right)
template<typename _Key_t , typename _Mapped_t >
void	swap (multimap< _Key_t, _Mapped_t >%_Left, multimap< _Key_t, _Mapped_t >%_Right)
template<class _Ty >
pair< _Ty *, std::ptrdiff_t >	get_temporary_buffer (std::ptrdiff_t _Count)
template<class _Ty >
void	return_temporary_buffer (_Ty *_Pbuf)
template<class _Ty >
void	swap (_Ty%_Left, _Ty%_Right)
template<class _InIt , class _OutIt >
_OutIt	copy_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	copy (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	copy_backward_unchecked (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
template<class _BidIt1 , class _BidIt2 >
_BidIt2	copy_backward (_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest)
template<class _InIt1 , class _InIt2 >
	mismatch_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
template<class _InIt1 , class _InIt2 >
	mismatch (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
template<class _InIt1 , class _InIt2 , class _Pr >
	mismatch_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
	mismatch (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
template<class _InIt1 , class _InIt2 >
bool	equal_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
template<class _InIt1 , class _InIt2 >
bool	equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2)
bool	equal (const char *_First1, const char *_Last1, const char *_First2)
bool	equal (const signed char *_First1, const signed char *_Last1, const signed char *_First2)
bool	equal (const unsigned char *_First1, const unsigned char *_Last1, const unsigned char *_First2)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	equal_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	equal (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred)
template<class _FwdIt , class _Ty >
void	fill_unchecked (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
void	fill_unchecked (_Out_writes_all_(_Last-_First) char *_First, _In_opt_ char *_Last, int _Val)
void	fill_unchecked (_Out_writes_all_(_Last-_First) signed char *_First, _In_opt_ signed char *_Last, int _Val)
void	fill_unchecked (_Out_writes_all_(_Last-_First) unsigned char *_First, _In_opt_ unsigned char *_Last, int _Val)
template<class _FwdIt , class _Ty >
void	fill (_FwdIt _First, _FwdIt _Last, const _Ty%_Val)
template<class _OutIt , class _Diff , class _Ty >
void	fill_n_unchecked (_OutIt _First, _Diff _Count, const _Ty%_Val)
void	fill_n_unchecked (_Out_writes_all_(_Count) char *_First, size_t _Count, int _Val)
void	fill_n_unchecked (_Out_writes_all_(_Count) signed char *_First, size_t _Count, int _Val)
void	fill_n_unchecked (_Out_writes_all_(_Count) unsigned char *_First, size_t _Count, int _Val)
template<class _OutIt , class _Diff , class _Ty >
void	fill_n (_OutIt _First, _Diff _Count, const _Ty%_Val)
template<class _InIt1 , class _InIt2 >
bool	lexicographical_compare_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
bool	lexicographical_compare_unchecked (const unsigned char *_First1, const unsigned char *_Last1, const unsigned char *_First2, const unsigned char *_Last2)
bool	lexicographical_compare_unchecked (const char *_First1, const char *_Last1, const char *_First2, const char *_Last2)
template<class _InIt1 , class _InIt2 >
bool	lexicographical_compare (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	lexicographical_compare_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _InIt1 , class _InIt2 , class _Pr >
bool	lexicographical_compare (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred)
template<class _Ty >
const _Ty()	max (const _Ty%_Left, const _Ty%_Right)
template<class _Ty , class _Pr >
const _Ty()	max (const _Ty%_Left, const _Ty%_Right, _Pr _Pred)
template<class _Ty >
const _Ty()	min (const _Ty%_Left, const _Ty%_Right)
template<class _Ty , class _Pr >
const _Ty()	min (const _Ty%_Left, const _Ty%_Right, _Pr _Pred)
template<class _InIt , class _Ty >
_Ty	accumulate_unchecked (_InIt _First, _InIt _Last, _Ty _Val)
template<class _InIt , class _Ty >
_Ty	accumulate (_InIt _First, _InIt _Last, _Ty _Val)
template<class _InIt , class _Ty , class _Fn2 >
_Ty	accumulate_unchecked (_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
template<class _InIt , class _Ty , class _Fn2 >
_Ty	accumulate (_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
template<class _InIt1 , class _InIt2 , class _Ty >
_Ty	inner_product_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
template<class _InIt1 , class _InIt2 , class _Ty >
_Ty	inner_product (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
template<class _InIt1 , class _InIt2 , class _Ty , class _Fn21 , class _Fn22 >
_Ty	inner_product_unchecked (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _Fn21 _Func1, _Fn22 _Func2)
template<class _InIt1 , class _InIt2 , class _Ty , class _Fn21 , class _Fn22 >
_Ty	inner_product (_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _Fn21 _Func1, _Fn22 _Func2)
template<class _InIt , class _OutIt >
_OutIt	partial_sum_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	partial_sum (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt	partial_sum_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn2 _Func)
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt	partial_sum (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn2 _Func)
template<class _InIt , class _OutIt >
_OutIt	adjacent_difference_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt >
_OutIt	adjacent_difference (_InIt _First, _InIt _Last, _OutIt _Dest)
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt	adjacent_difference_unchecked (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn2 _Func)
template<class _InIt , class _OutIt , class _Fn2 >
_OutIt	adjacent_difference (_InIt _First, _InIt _Last, _OutIt _Dest, _Fn2 _Func)
template<typename _Value_t , typename _Cont_t >
bool	operator== (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator!= (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator< (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator>= (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator> (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator<= (queue< _Value_t, _Cont_t >%_Left, queue< _Value_t, _Cont_t >%_Right)
template<typename _Key_t >
bool	_Queue_compare (_Key_t _Left, _Key_t _Right)
bool	_Queue_compare (System::String^_Left, System::String^_Right)
template<typename _Key_t >
void	swap (set< _Key_t >%_Left, set< _Key_t >%_Right)
template<typename _Key_t >
void	swap (multiset< _Key_t >%_Left, multiset< _Key_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator== (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator!= (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator< (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator>= (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator> (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
template<typename _Value_t , typename _Cont_t >
bool	operator<= (stack< _Value_t, _Cont_t >%_Left, stack< _Value_t, _Cont_t >%_Right)
template<class _Ty1 , class _Ty2 >
void	swap (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
template<class _Ty1 , class _Ty2 >
bool	operator== (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
template<class _Ty1 , class _Ty2 >
bool	operator!= (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
template<class _Ty1 , class _Ty2 >
bool	operator< (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
template<class _Ty1 , class _Ty2 >
bool	operator> (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
template<class _Ty1 , class _Ty2 >
bool	operator<= (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
template<class _Ty1 , class _Ty2 >
bool	operator>= (pair< _Ty1, _Ty2 >%_Left, pair< _Ty1, _Ty2 >%_Right)
template<class _Ty1 , class _Ty2 >
pair< _Ty1, _Ty2 >	make_pair (_Ty1 _Val1, _Ty2 _Val2)
template<typename _Value_t >
bool	operator== (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
template<typename _Value_t >
bool	operator!= (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
template<typename _Value_t >
bool	operator< (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
template<typename _Value_t >
bool	operator>= (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
template<typename _Value_t >
bool	operator> (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
template<typename _Value_t >
bool	operator<= (System::IComparable< _Value_t >^_Left, System::IComparable< _Value_t >^_Right)
template<typename _Value_t >
bool	operator== (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
template<typename _Value_t >
bool	operator!= (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
template<typename _Value_t >
bool	operator< (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
template<typename _Value_t >
bool	operator>= (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
template<typename _Value_t >
bool	operator> (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
template<typename _Value_t >
bool	operator<= (System::IComparable< _Value_t >%_Left, System::IComparable< _Value_t >%_Right)
bool	operator== (System::IComparable^_Left, System::IComparable^_Right)
bool	operator!= (System::IComparable^_Left, System::IComparable^_Right)
bool	operator< (System::IComparable^_Left, System::IComparable^_Right)
bool	operator>= (System::IComparable^_Left, System::IComparable^_Right)
bool	operator> (System::IComparable^_Left, System::IComparable^_Right)
bool	operator<= (System::IComparable^_Left, System::IComparable^_Right)
bool	operator== (System::IComparable%_Left, System::IComparable%_Right)
bool	operator!= (System::IComparable%_Left, System::IComparable%_Right)
bool	operator< (System::IComparable%_Left, System::IComparable%_Right)
bool	operator>= (System::IComparable%_Left, System::IComparable%_Right)
bool	operator> (System::IComparable%_Left, System::IComparable%_Right)
bool	operator<= (System::IComparable%_Left, System::IComparable%_Right)
template<typename _Value_t >
bool	operator== (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
template<typename _Value_t >
bool	operator!= (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
template<typename _Value_t >
bool	operator< (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
template<typename _Value_t >
bool	operator>= (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
template<typename _Value_t >
bool	operator> (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
template<typename _Value_t >
bool	operator<= (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
template<typename _Value_t >
void	swap (vector< _Value_t >%_Left, vector< _Value_t >%_Right)
template<typename _Key_t >
bool	_Hash_key_compare (_Key_t _Left, _Key_t _Right)
bool	_Hash_key_compare (System::String^_Left, System::String^_Right)
int	hash_value (System::Object^_Key)
template<typename _Traits_t >
void	swap (cliext::impl::hash< _Traits_t >%_Left, cliext::impl::hash< _Traits_t >%_Right)
template<typename _Traits_t >
bool	operator== (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
template<typename _Traits_t >
bool	operator!= (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
template<typename _Traits_t >
bool	operator< (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
template<typename _Traits_t >
bool	operator>= (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
template<typename _Traits_t >
bool	operator> (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
template<typename _Traits_t >
bool	operator<= (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
template<typename _Traits_t >
void	swap (cliext::impl::tree< _Traits_t >%_Left, cliext::impl::tree< _Traits_t >%_Right)
template<typename Mycont >
Mycont	_Handle_alloc (Mycont^)
template<typename _InIt_t , typename _Diff_t >
void	_Iter_advance (_InIt_t%_Where, _Diff_t _Off, input_iterator_tag)
template<typename _BidIt_t , typename _Diff_t >
void	_Iter_advance (_BidIt_t%_Where, _Diff_t _Off, bidirectional_iterator_tag)
template<typename _RanIt_t , typename _Diff_t >
void	_Iter_advance (_RanIt_t%_Where, _Diff_t _Off, random_access_iterator_tag)
template<typename _InIt_t , typename _Diff_t >
void	advance (_InIt_t%_Where, _Diff_t _Off)
template<typename _InIt_t , typename _Diff_t >
void	_Iter_distance2 (_InIt_t _First, _InIt_t _Last, _Diff_t%_Off, input_iterator_tag)
template<typename _RanIt_t , typename _Diff_t >
void	_Iter_distance2 (_RanIt_t _First, _RanIt_t _Last, _Diff_t%_Off, random_access_iterator_tag)
template<typename _InIt_t >
int	distance (_InIt_t _First, _InIt_t _Last)
template<typename _InIt_t , typename _Diff_t >
void	_Iter_distance (_InIt_t _First, _InIt_t _Last, _Diff_t%_Off)

Variables
_FwdIt	_Last
_FwdIt const _Ty	_Val
_Diff	_Count = 0
_FwdIt const _Ty _Pr	_Pred
_RanIt	_Pfirst = _Mid
_RanIt	_Plast = _Pfirst + 1
_RanIt	_Gfirst = _Plast
_RanIt	_Glast = _Pfirst
template<class _Iter_t >
iterator_traits< _Iter_t >::iterator_category	_Iter_category (_Iter_t)

Function Documentation

template<typename Mycont >

Mycont cliext::_Handle_alloc ( Mycont^  )

inline

    {   // allocate a container, given its handle type
    return (gcnew Mycont);
    }

template<typename _Key_t >

bool cliext::_Hash_key_compare ( _Key_t  _Left, _Key_t  _Right  )

inline

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

bool cliext::_Hash_key_compare ( System::String^  _Left, System::String^  _Right  )

inline

    {   // test if _Left <= _Right for String
    return (!(_Right->CompareTo(_Left) < 0));
    }

template<typename _InIt_t , typename _Diff_t >

void cliext::_Iter_advance ( _InIt_t%  _Where, _Diff_t  _Off, input_iterator_tag    )

inline

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

template<typename _BidIt_t , typename _Diff_t >

void cliext::_Iter_advance ( _BidIt_t%  _Where, _Diff_t  _Off, bidirectional_iterator_tag    )

inline

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

template<typename _RanIt_t , typename _Diff_t >

void cliext::_Iter_advance ( _RanIt_t%  _Where, _Diff_t  _Off, random_access_iterator_tag    )

inline

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

template<typename _Iter_t >

System::Object cliext::_Iter_container ( _Iter_t%  _Next )

inline

    {   // get container for arbitrary iterator
    return (_Next.container());
    }

template<typename _Iter_t >

System::Object cliext::_Iter_container ( _Iter_t^  _Next )

inline

    {   // get container for arbitrary iterator
    return (_Next->container());
    }

template<typename _InIt_t , typename _Diff_t >

void cliext::_Iter_distance ( _InIt_t  _First, _InIt_t  _Last, _Diff_t%  _Off  )

inline

    {   // add to _Off distance between iterators
    _Iter_distance2(_First, _Last, _Off, _Iter_category(_First));
    }

cliext::_Iter_distance	(	_First	,
		_Last	,
		_Count
	)

template<typename _InIt_t , typename _Diff_t >

void cliext::_Iter_distance2 ( _InIt_t  _First, _InIt_t  _Last, _Diff_t%  _Off, input_iterator_tag    )

inline

    {   // add to _Off distance between input iterators
    for (; _First != _Last; ++_First)
        ++_Off;
    }

template<typename _RanIt_t , typename _Diff_t >

void cliext::_Iter_distance2 ( _RanIt_t  _First, _RanIt_t  _Last, _Diff_t%  _Off, random_access_iterator_tag    )

inline

    {   // add to _Off distance between random-access iterators
    _Off += (_Diff_t)(_Last - _First);
    }

template<class _FwdIt , class _Ty >

cliext::_PAIR_TYPE ( _FwdIt  )

inline

template<class _FwdIt , class _Ty , class _Pr >

cliext::_PAIR_TYPE ( _FwdIt  )

inline

template<class _RanIt >

cliext::_PAIR_TYPE ( _RanIt  )

inline

template<class _RanIt , class _Pr >

cliext::_PAIR_TYPE ( _RanIt  )

inline

template<typename _Key_t >

bool cliext::_Queue_compare ( _Key_t  _Left, _Key_t  _Right  )

inline

    {   // test if _Left < _Right
    return (_Left < _Right);
    }

bool cliext::_Queue_compare ( System::String^  _Left, System::String^  _Right  )

inline

    {   // test if _Left < _Right for String
    return (_Left->CompareTo(_Right) < 0);
    }

int cliext::_Rand ( void  )

inline

    {   /* compute pseudo-random value */
    static long _Randseed = 1;

    _Randseed = _Randseed * 1103515245 + 12345;
    return ((unsigned int)(_Randseed >> 16) & 0x7fff);
    }

template<class _BidIt >

void cliext::_Reverse ( _BidIt  _First, _BidIt  _Last, bidirectional_iterator_tag    )

inline

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

template<class _RanIt >

void cliext::_Reverse ( _RanIt  _First, _RanIt  _Last, random_access_iterator_tag    )

inline

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

template<class _FwdIt >

void cliext::_Rotate ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last, forward_iterator_tag    )

inline

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

template<class _BidIt >

void cliext::_Rotate ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last, bidirectional_iterator_tag    )

inline

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

template<class _RanIt >

void cliext::_Rotate ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, random_access_iterator_tag    )

inline

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

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

    for (_Diff _Factor = _Shift; _Factor != 0; )
        {   // find subcycle count as GCD of shift count and length
        _Diff _Tmp = _Count % _Factor;
        _Count = _Factor, _Factor = _Tmp;
        }

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

template<class _FwdIt1 , class _Diff2 , class _Ty >

_FwdIt1 cliext::_Search_n ( _FwdIt1  _First1, _FwdIt1  _Last1, _Diff2  _Count, const _Ty%  _Val, forward_iterator_tag    )

inline

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

    for (; _First1 != _Last1; ++_First1)
        if (*_First1 == _Val)
            {   // found start of possible match, check it out
            _FwdIt1 _Mid1  = _First1;

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

            _First1 = _Mid1;    // pick up just beyond failed match
            }
    return (_Last1);
    }

template<class _FwdIt1 , class _Diff2 , class _Ty >

_FwdIt1 cliext::_Search_n ( _FwdIt1  _First1, _FwdIt1  _Last1, _Diff2  _Count, const _Ty%  _Val, random_access_iterator_tag    )

inline

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

    _FwdIt1 _Oldfirst1 = _First1;
    for (; _Count <= _Last1 - _Oldfirst1; )
        {   // enough room, look for a match
        if (*_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)
                for (; ; )  // enough left, test suffix
                    if (--_Count1 == 0)
                        return (_First1);   // found rest of match, report it
                    else if (!(*++_Mid1 == _Val))
                        break;  // short match not at end

            _Oldfirst1 = ++_Mid1;   // failed match, take small jump
            _First1 = _Oldfirst1;
            }
        else
            {   // no match, take big jump and back up as needed
            _Oldfirst1 = _First1 + 1;
            _First1 += _Count;
            }
        }
    return (_Last1);
    }

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    )

inline

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

    for (; _First1 != _Last1; ++_First1)
        if (_Pred(*_First1, _Val))
            {   // found start of possible match, check it out
            _FwdIt1 _Mid1  = _First1;

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

            _First1 = _Mid1;    // pick up just beyond failed match
            }
    return (_Last1);
    }

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    )

inline

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

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

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

            if (_Count1 <= _Last1 - _Mid1)
                for (; ; )  // enough left, test suffix
                    if (--_Count1 == 0)
                        return (_First1);   // found rest of match, report it
                    else if (!_Pred(*++_Mid1, _Val))
                        break;  // short match not at end

            _Oldfirst1 = ++_Mid1;   // failed match, take small jump
            _First1 = _Oldfirst1;
            }
        else
            {   // no match, take big jump and back up as needed
            _Oldfirst1 = _First1 + 1;
            _First1 += _Count;
            }
        }
    return (_Last1);
    }

template<typename _Iter_t >

_Iter_t cliext::_Unchecked ( _Iter_t  _Iter )

inline

    {   // return unknown iterator unchanged
    return (_Iter);
    }

template<typename _Cont_t >

ConstUncheckedBidirectionalIterator<_Cont_t> cliext::_Unchecked

(

ConstBidirectionalIterator< _Cont_t >

_Iter

)

    {   // return unchecked version
    ConstUncheckedBidirectionalIterator<_Cont_t> _Newiter(
        (typename _Cont_t::node_type^)_Iter.get_node());

    return (_Newiter);
    }

template<typename _Cont_t >

UncheckedBidirectionalIterator<_Cont_t> cliext::_Unchecked

(

BidirectionalIterator< _Cont_t >

_Iter

)

    {   // return unchecked version
    UncheckedBidirectionalIterator<_Cont_t> _Newiter(
        (typename _Cont_t::node_type^)_Iter.get_node());

    return (_Newiter);
    }

template<typename _Cont_t >

ReverseBidirectionalIterator<_Cont_t> cliext::_Unchecked

(

ReverseBidirectionalIterator< _Cont_t >

_Iter

)

    {   // return unchecked version
    ReverseBidirectionalIterator<_Cont_t> _Newiter(_Iter.base());

    return (_Newiter);
    }

template<typename _Cont_t >

ConstUncheckedRandomAccessIterator<_Cont_t> cliext::_Unchecked

(

ConstRandomAccessIterator< _Cont_t >

_Iter

)

    {   // return unchecked version
    typedef typename _Cont_t::value_type _Value_t;

    return (ConstUncheckedRandomAccessIterator<_Cont_t>(
        (_Cont_t^)_Iter.container(),
        _Iter.get_bias()));
    }

template<typename _Cont_t >

UncheckedRandomAccessIterator<_Cont_t> cliext::_Unchecked

(

RandomAccessIterator< _Cont_t >

_Iter

)

    {   // return unchecked version
    typedef typename _Cont_t::value_type _Value_t;

    return (UncheckedRandomAccessIterator<_Cont_t>(
        (_Cont_t^)_Iter.container(),
        _Iter.get_bias()));
    }

template<typename _Cont_t >

ReverseRandomAccessIterator<_Cont_t> cliext::_Unchecked

(

ReverseRandomAccessIterator< _Cont_t >

_Iter

)

    {   // return unchecked version
    ReverseRandomAccessIterator<_Cont_t> _Newiter(_Iter.base());

    return (_Newiter);
    }

template<typename _Cont_t , bool _Is_ref>

UncheckedBCL_iterator<_Cont_t, _Is_ref> cliext::_Unchecked

(

BCL_iterator< _Cont_t, _Is_ref >

_Iter

)

    {   // return unchecked version
    return (UncheckedBCL_iterator<_Cont_t, _Is_ref>(
        (_Cont_t^)_Iter.container(),
        _Iter.get_bias()));
    }

template<class _InIt , class _OutIt >

_OutIt cliext::_Unique_copy ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, input_iterator_tag    )

inline

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

    _Ty _Val = *_First;

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

template<class _FwdIt , class _OutIt >

_OutIt cliext::_Unique_copy ( _FwdIt  _First, _FwdIt  _Last, _OutIt  _Dest, forward_iterator_tag    )

inline

    {   // copy compressing pairs that match, forward iterators
    _FwdIt _Firstb = _First;
    for (*_Dest++ = *_Firstb; ++_First != _Last; )
        if (!(*_Firstb == *_First))
            _Firstb = _First, *_Dest++ = *_Firstb;
    return (_Dest);
    }

template<class _BidIt , class _OutIt >

_OutIt cliext::_Unique_copy ( _BidIt  _First, _BidIt  _Last, _OutIt  _Dest, bidirectional_iterator_tag    )

inline

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

template<class _RanIt , class _OutIt >

_OutIt cliext::_Unique_copy ( _RanIt  _First, _RanIt  _Last, _OutIt  _Dest, random_access_iterator_tag    )

inline

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

template<class _InIt , class _OutIt , class _Pr >

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

inline

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

    _Ty _Val = *_First;

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

template<class _FwdIt , class _OutIt , class _Pr >

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

inline

    {   // copy compressing pairs satisfying _Pred, forward iterators
    _FwdIt _Firstb = _First;

    for (*_Dest++ = *_Firstb; ++_First != _Last; )
        if (!_Pred(*_Firstb, *_First))
            _Firstb = _First, *_Dest++ = *_Firstb;
    return (_Dest);
    }

template<class _BidIt , class _OutIt , class _Pr >

_OutIt cliext::_Unique_copy ( _BidIt  _First, _BidIt  _Last, _OutIt  _Dest, _Pr  _Pred, bidirectional_iterator_tag    )

inline

    {   // copy compressing pairs satisfying _Pred, bidirectional iterators
    return (_Unique_copy(_First, _Last, _Dest, _Pred,
        forward_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    )

inline

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

template<class _RanIt , class _Diff , class _Ty >

void cliext::_XAdjust_heap ( _RanIt  _First, _Diff  _Hole, _Diff  _Bottom, _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
        if (_STLCLRDB_LT(*(_First + _Idx), *(_First + (_Idx - 1))))
            --_Idx;
        *(_First + _Hole) = *(_First + _Idx), _Hole = _Idx;
        }

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

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

void cliext::_XAdjust_heap ( _RanIt  _First, _Diff  _Hole, _Diff  _Bottom, _Ty  _Val, _Pr  _Pred  )

inline

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

    for (; _Idx < _Bottom; _Idx = 2 * _Idx + 2)
        {   // move _Hole down to larger child
        if (_STLCLRDB_LT_PRED(_Pred, *(_First + _Idx),
            *(_First + (_Idx - 1))))
            --_Idx;
        *(_First + _Hole) = *(_First + _Idx), _Hole = _Idx;
        }

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

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  )

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;

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

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

template<class _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  )

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());
        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);
        }
    else
        {   // buffer too small, divide and conquer
        _BidIt _Firstn, _Lastn;
        _Diff _Count1n, _Count2n;
        if (_Count2 < _Count1)
            {   // left larger, cut it in half and partition right to match
            _Count1n = _Count1 / 2, _Count2n = 0;
            _Firstn = _First;
            cliext::advance(_Firstn, _Count1n);
            _Lastn = cliext::lower_bound_unchecked(_Mid, _Last,
                *_Firstn, _Pred);
            _Iter_distance(_Mid, _Lastn, _Count2n);
            }
        else
            {   // right larger, cut it in half and partition left to match
            _Count1n = 0, _Count2n = _Count2 / 2;
            _Lastn = _Mid;
            cliext::advance(_Lastn, _Count2n);
            _Firstn = cliext::upper_bound_unchecked(_First, _Mid,
                *_Lastn, _Pred);
            _Iter_distance(_First, _Firstn, _Count1n);
            }
        _BidIt _Midn = cliext::_XBuffered_rotate(_Firstn, _Mid, _Lastn,
            _Count1 - _Count1n, _Count2n, _Tempbuf);    // rearrange middle
        cliext::_XBuffered_merge(_First, _Firstn, _Midn,
            _Count1n, _Count2n, _Tempbuf, _Pred);   // merge each new part
        cliext::_XBuffered_merge(_Midn, _Lastn, _Last,
            _Count1 - _Count1n, _Count2 - _Count2n, _Tempbuf, _Pred);
        }
    }

template<class _BidIt , class _Diff , class _Ty >

void cliext::_XBuffered_merge_sort ( _BidIt  _First, _BidIt  _Last, _Diff  _Count, _Temp_iterator< _Ty >  _Tempbuf  )

inline

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

        cliext::_XInsertion_sort(_Mid, _Midend);
        _Mid = _Midend;
        }
    cliext::_XInsertion_sort(_Mid, _Last);  // sort partial last chunk

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

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  )

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

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

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  )

inline

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

template<class _BidIt , class _OutIt , class _Diff >

void cliext::_XChunked_merge ( _BidIt  _First, _BidIt  _Last, _OutIt  _Dest, _Diff  _Chunk, _Diff  _Count  )

inline

    {   // copy merging chunks, using operator<
    for (_Diff _Chunk2 = _Chunk * 2; _Chunk2 <= _Count; _Count -= _Chunk2)
        {   // copy merging pairs of adjacent chunks
        _BidIt _Mid1 = _First;
        cliext::advance(_Mid1, _Chunk);
        _BidIt _Mid2 = _Mid1;
        cliext::advance(_Mid2, _Chunk);

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

    if (_Count <= _Chunk)
        cliext::copy_unchecked(_First, _Last,
            _Dest); // copy partial last chunk
    else
        {   // copy merging whole and partial last chunk
        _BidIt _Mid = _First;
        cliext::advance(_Mid, _Chunk);

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

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

void cliext::_XChunked_merge ( _BidIt  _First, _BidIt  _Last, _OutIt  _Dest, _Diff  _Chunk, _Diff  _Count, _Pr  _Pred  )

inline

    {   // copy merging chunks, using _Pred
    for (_Diff _Chunk2 = _Chunk * 2; _Chunk2 <= _Count; _Count -= _Chunk2)
        {   // copy merging pairs of adjacent chunks
        _BidIt _Mid1 = _First;
        cliext::advance(_Mid1, _Chunk);
        _BidIt _Mid2 = _Mid1;
        cliext::advance(_Mid2, _Chunk);

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

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

void cliext::_XInsertion_sort ( _BidIt  _First, _BidIt  _Last  )

inline

    {   // insertion sort [_First, _Last), using operator<
    typedef iterator_traits<_BidIt>::value_type _Ty;

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

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

template<class _BidIt , class _Pr >

void cliext::_XInsertion_sort ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred  )

inline

    {   // insertion sort [_First, _Last), using _Pred
    typedef iterator_traits<_BidIt>::value_type _Ty;

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

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

template<class _RanIt >

void cliext::_XMed3 ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last  )

inline

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

template<class _RanIt , class _Pr >

void cliext::_XMed3 ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, _Pr  _Pred  )

inline

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

template<class _RanIt >

void cliext::_XMedian ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last  )

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

void cliext::_XMedian ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, _Pr  _Pred  )

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, _Pred);
        cliext::_XMed3(_Mid - _Step, _Mid, _Mid + _Step, _Pred);
        cliext::_XMed3(_Last - 2 * _Step, _Last - _Step, _Last, _Pred);
        cliext::_XMed3(_First + _Step, _Mid, _Last - _Step, _Pred);
        }
    else
        cliext::_XMed3(_First, _Mid, _Last, _Pred);
    }

template<class _BidIt1 , class _BidIt2 , class _BidIt3 >

_BidIt3 cliext::_XMerge_backward ( _BidIt1  _First1, _BidIt1  _Last1, _BidIt2  _First2, _BidIt2  _Last2, _BidIt3  _Dest  )

inline

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

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  )

inline

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

template<class _RanIt , class _Ty >

void cliext::_XPop_heap ( _RanIt  _First, _RanIt  _Last, _RanIt  _Dest, _Ty  _Val  )

inline

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

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

template<class _RanIt , class _Ty , class _Pr >

void cliext::_XPop_heap ( _RanIt  _First, _RanIt  _Last, _RanIt  _Dest, _Ty  _Val, _Pr  _Pred  )

inline

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

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

template<class _RanIt , class _Diff , class _Ty >

void cliext::_XPush_heap ( _RanIt  _First, _Diff  _Hole, _Diff  _Top, _Ty  _Val  )

inline

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

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

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

void cliext::_XPush_heap ( _RanIt  _First, _Diff  _Hole, _Diff  _Top, _Ty  _Val, _Pr  _Pred  )

inline

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

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

template<class _RanIt , class _Diff >

void cliext::_XSort ( _RanIt  _First, _RanIt  _Last, _Diff  _Ideal  )

inline

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

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

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

template<class _RanIt , class _Diff , class _Pr >

void cliext::_XSort ( _RanIt  _First, _RanIt  _Last, _Diff  _Ideal, _Pr  _Pred  )

inline

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

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

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

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

_BidIt cliext::_XStable_partition ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred, _Diff  _Count, _Temp_iterator< _Ty >  _Tempbuf  )

inline

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

        cliext::copy_unchecked(_Tempbuf._First(), _Tempbuf._Last(),
            _Next); // copy back
        return (_Next);
        }
    else
        {   // temp buffer not big enough, divide and conquer
        _BidIt _Mid = _First;
        cliext::advance(_Mid, _Count / 2);

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

        _Diff _Count1 = 0;
        _Iter_distance(_Left, _Mid, _Count1);
        _Diff _Count2 = 0;
        _Iter_distance(_Mid, _Right, _Count2);

        return (cliext::_XBuffered_rotate(_Left, _Mid, _Right,
            _Count1, _Count2, _Tempbuf));   // rotate L1R1L2R2 to L1L2R1R2
        }
    }

template<class _BidIt , class _Diff , class _Ty >

void cliext::_XStable_sort ( _BidIt  _First, _BidIt  _Last, _Diff  _Count, _Temp_iterator< _Ty >  _Tempbuf  )

inline

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

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

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

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  )

inline

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

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

template<class _InIt , class _Ty >

_Ty cliext::accumulate ( _InIt  _First, _InIt  _Last, _Ty  _Val  )

inline

    {   // return sum of _Val and all in [_First, _Last)
    _STLCLRDB_RANGE(_First, _Last);
    return (cliext::accumulate_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Val));
    }

template<class _InIt , class _Ty , class _Fn2 >

_Ty cliext::accumulate ( _InIt  _First, _InIt  _Last, _Ty  _Val, _Fn2  _Func  )

inline

    {   // return sum of _Val and all in [_First, _Last), using _Func
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Func);
    return (cliext::accumulate_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Val, _Func));
    }

template<class _InIt , class _Ty >

_Ty cliext::accumulate_unchecked ( _InIt  _First, _InIt  _Last, _Ty  _Val  )

inline

    {   // return sum of _Val and all in [_First, _Last)
    for (; _First != _Last; ++_First)
        _Val = _Val + *_First;
    return (_Val);
    }

template<class _InIt , class _Ty , class _Fn2 >

_Ty cliext::accumulate_unchecked ( _InIt  _First, _InIt  _Last, _Ty  _Val, _Fn2  _Func  )

inline

    {   // return sum of _Val and all in [_First, _Last), using _Func
    for (; _First != _Last; ++_First)
        _Val = _Func(_Val, *_First);
    return (_Val);
    }

template<class _InIt , class _OutIt >

_OutIt cliext::adjacent_difference ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // compute adjacent differences into _Dest
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::adjacent_difference_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest)));
    }

template<class _InIt , class _OutIt , class _Fn2 >

_OutIt cliext::adjacent_difference ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Fn2  _Func  )

inline

    {   // compute adjacent differences into _Dest, using _Func
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    _STLCLRDB_POINTER(_Func);
    return (cliext::adjacent_difference_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest), _Func));
    }

template<class _InIt , class _OutIt >

_OutIt cliext::adjacent_difference_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // compute adjacent differences into _Dest
    typedef iterator_traits<_InIt>::value_type _Ty;

    if (_First == _Last)
        return (_Dest);
    else
        {   // compute nontrivial difference
        _Ty _Val = *_First;

        for (*_Dest = _Val; ++_First != _Last; )
            {   // compute another difference
            _Ty _Tmp = *_First;

            *++_Dest = _Tmp - _Val;
            _Val = _Tmp;
            }
        return (++_Dest);
        }
    }

template<class _InIt , class _OutIt , class _Fn2 >

_OutIt cliext::adjacent_difference_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Fn2  _Func  )

inline

    {   // compute adjacent differences into _Dest, using _Func
    typedef iterator_traits<_InIt>::value_type _Ty;

    if (_First == _Last)
        return (_Dest);
    else
        {   // compute nontrivial difference
        _Ty _Val = *_First;

        for (*_Dest = _Val; ++_First != _Last; )
            {   // compute another difference
            _Ty _Tmp = *_First;

            *++_Dest = _Func(_Tmp, _Val);
            _Val = _Tmp;
            }
        return (++_Dest);
        }
    }

template<class _FwdIt >

_FwdIt cliext::adjacent_find ( _FwdIt  _First, _FwdIt  _Last  )

inline

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

template<class _FwdIt , class _Pr >

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

inline

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

template<class _FwdIt >

_FwdIt cliext::adjacent_find_unchecked ( _FwdIt  _First, _FwdIt  _Last  )

inline

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

template<class _FwdIt , class _Pr >

_FwdIt cliext::adjacent_find_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

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

template<typename _InIt_t , typename _Diff_t >

void cliext::advance ( _InIt_t%  _Where, _Diff_t  _Off  )

inline

    {   // increment iterator by _Off, arbitrary iterators
    _Iter_advance(_Where, _Off, _Iter_category(_Where));
    }

template<typename TArg1 , typename TArg2 , typename TResult >

delegate TResult cliext::binary_delegate	(	TArg1	,
		TArg2
	)

template<typename TArg1 , typename TArg2 >

delegate void cliext::binary_delegate_noreturn	(	TArg1	,
		TArg2
	)

template<class _FwdIt , class _Ty >

bool cliext::binary_search ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val  )

inline

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

template<class _FwdIt , class _Ty , class _Pr >

bool cliext::binary_search ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val, _Pr  _Pred  )

inline

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

template<class _FwdIt , class _Ty >

bool cliext::binary_search_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val  )

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

bool cliext::binary_search_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val, _Pr  _Pred  )

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<typename _Fun_t , typename _Arg_t >

binder1st<_Fun_t> cliext::bind1st ( _Fun_t%  _Func, _Arg_t  _Left  )

inline

    {   // return a binder1st functor adapter
    typename _Fun_t::first_argument_type _Val = _Left;

    return (binder1st<_Fun_t>(_Func, _Val));
    }

template<typename _Fun_t , typename _Arg_t >

binder2nd<_Fun_t> cliext::bind2nd ( _Fun_t%  _Func, _Arg_t  _Right  )

inline

    {   // return a binder2nd functor adapter
    typename _Fun_t::second_argument_type _Val = _Right;

    return (binder2nd<_Fun_t>(_Func, _Val));
    }

template<class _InIt , class _OutIt >

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

inline

    {   // copy [_First, _Last) to [_Dest, ...)
 #if _HAS_ITERATOR_DEBUGGING
    _STLCLRDB_RANGE(_First, _Last);
    if (_First != _Last)
        _STLCLRDB_POINTER(_Dest);
 #endif /* _HAS_ITERATOR_DEBUGGING */
    return (cliext::copy_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest)));
    }

template<class _BidIt1 , class _BidIt2 >

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

inline

    {   // copy [_First, _Last) backwards to [..., _Dest)
 #if _HAS_ITERATOR_DEBUGGING
    _STLCLRDB_RANGE(_First, _Last);
    if (_First != _Last)
        _STLCLRDB_POINTER(_Dest);
 #endif /* _HAS_ITERATOR_DEBUGGING */
    return (cliext::copy_backward_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest)));
    }

template<class _BidIt1 , class _BidIt2 >

_BidIt2 cliext::copy_backward_unchecked ( _BidIt1  _First, _BidIt1  _Last, _BidIt2  _Dest  )

inline

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

template<class _InIt , class _OutIt >

_OutIt cliext::copy_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

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

template<class _InIt , class _Ty >

iterator_traits<_InIt>::difference_type cliext::count ( _InIt  _First, _InIt  _Last, const _Ty%  _Val  )

inline

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

template<class _InIt , class _Pr >

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

inline

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

template<class _InIt , class _Pr >

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

inline

    {   // count elements satisfying _Pred
    typename iterator_traits<_InIt>::difference_type _Count = 0;

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

template<class _InIt , class _Ty >

iterator_traits<_InIt>::difference_type cliext::count_unchecked ( _InIt  _First, _InIt  _Last, const _Ty%  _Val  )

inline

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

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

template<typename _InIt_t >

int cliext::distance ( _InIt_t  _First, _InIt_t  _Last  )

inline

    {   // return distance between iterators
    int _Off = 0;

    _Iter_distance2(_First, _Last, _Off, _Iter_category(_First));
    return (_Off);
    }

template<class _InIt1 , class _InIt2 >

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

inline

    {   // compare [_First1, _Last1) to [First2, ...)
 #if _HAS_ITERATOR_DEBUGGING
    _STLCLRDB_RANGE(_First1, _Last1);
    if (_First1 != _Last1)
        _STLCLRDB_POINTER(_First2);
 #endif /* _HAS_ITERATOR_DEBUGGING */
    return (cliext::equal_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2)));
    }

bool cliext::equal ( const char *  _First1, const char *  _Last1, const char *  _First2  )

inline

    {   // compare [_First1, _Last1) to [First2, ...), for chars
 #if _HAS_ITERATOR_DEBUGGING
    _STLCLRDB_RANGE(_First1, _Last1);
    if (_First1 != _Last1)
        _STLCLRDB_POINTER(_First2);
 #endif /* _HAS_ITERATOR_DEBUGGING */

    return (std::memcmp(_First1, _First2, _Last1 - _First1) == 0);
    }

bool cliext::equal ( const signed char *  _First1, const signed char *  _Last1, const signed char *  _First2  )

inline

    {   // compare [_First1, _Last1) to [First2, ...), for signed chars
 #if _HAS_ITERATOR_DEBUGGING
    _STLCLRDB_RANGE(_First1, _Last1);
    if (_First1 != _Last1)
        _STLCLRDB_POINTER(_First2);
 #endif /* _HAS_ITERATOR_DEBUGGING */

    return (std::memcmp(_First1, _First2, _Last1 - _First1) == 0);
    }

bool cliext::equal ( const unsigned char *  _First1, const unsigned char *  _Last1, const unsigned char *  _First2  )

inline

    {   // compare [_First1, _Last1) to [First2, ...), for unsigned chars
 #if _HAS_ITERATOR_DEBUGGING
    _STLCLRDB_RANGE(_First1, _Last1);
    if (_First1 != _Last1)
        _STLCLRDB_POINTER(_First2);
 #endif /* _HAS_ITERATOR_DEBUGGING */

    return (std::memcmp(_First1, _First2, _Last1 - _First1) == 0);
    }

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

    {   // compare [_First1, _Last1) to [First2, ...) using _Pred
 #if _HAS_ITERATOR_DEBUGGING
    _STLCLRDB_RANGE(_First1, _Last1);
    if (_First1 != _Last1)
        _STLCLRDB_POINTER(_First2);
    _STLCLRDB_POINTER(_Pred);
 #endif /* _HAS_ITERATOR_DEBUGGING */
    return (cliext::equal_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Pred));
    }

template<class _InIt1 , class _InIt2 >

bool cliext::equal_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2  )

inline

    {   // compare [_First1, _Last1) to [First2, ...)
    for (; _First1 != _Last1; ++_First1, ++_First2)
        if (!(*_First1 == *_First2))
            return (false);
    return (true);
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool cliext::equal_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr  _Pred  )

inline

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

template<class _FwdIt , class _Ty >

void cliext::fill ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val  )

inline

    {   // copy _Val through [_First, _Last)
    _STLCLRDB_RANGE(_First, _Last);
    cliext::fill_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val);
    }

template<class _OutIt , class _Diff , class _Ty >

void cliext::fill_n ( _OutIt  _First, _Diff  _Count, const _Ty%  _Val  )

inline

    {   // copy _Val _Count times through [_First, ...)
 #if _HAS_ITERATOR_DEBUGGING
    if (0 < _Count)
        _STLCLRDB_POINTER(_First);
 #endif /* _HAS_ITERATOR_DEBUGGING */

    cliext::fill_n_unchecked(_Unchecked(_First), _Count, _Val);
    }

template<class _OutIt , class _Diff , class _Ty >

void cliext::fill_n_unchecked ( _OutIt  _First, _Diff  _Count, const _Ty%  _Val  )

inline

    {   // copy _Val _Count times through [_First, ...)
    for (; 0 < _Count; --_Count, ++_First)
        *_First = _Val;
    }

void cliext::fill_n_unchecked ( _Out_writes_all_(_Count) char *  _First, size_t  _Count, int  _Val  )

inline

    {   // copy char _Val _Count times through [_First, ...)
    std::memset(_First, _Val, _Count);
    }

void cliext::fill_n_unchecked ( _Out_writes_all_(_Count) signed char *  _First, size_t  _Count, int  _Val  )

inline

    {   // copy signed char _Val _Count times through [_First, ...)
    std::memset(_First, _Val, _Count);
    }

void cliext::fill_n_unchecked ( _Out_writes_all_(_Count) unsigned char *  _First, size_t  _Count, int  _Val  )

inline

    {   // copy unsigned char _Val _Count times through [_First, ...)
    std::memset(_First, _Val, _Count);
    }

template<class _FwdIt , class _Ty >

void cliext::fill_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val  )

inline

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

void cliext::fill_unchecked ( _Out_writes_all_(_Last-_First) char *  _First, _In_opt_ char *  _Last, int  _Val  )

inline

    {   // copy char _Val through [_First, _Last)
    std::memset(_First, _Val, _Last - _First);
    }

void cliext::fill_unchecked ( _Out_writes_all_(_Last-_First) signed char *  _First, _In_opt_ signed char *  _Last, int  _Val  )

inline

    {   // copy signed char _Val through [_First, _Last)
    std::memset(_First, _Val, _Last - _First);
    }

void cliext::fill_unchecked ( _Out_writes_all_(_Last-_First) unsigned char *  _First, _In_opt_ unsigned char *  _Last, int  _Val  )

inline

    {   // copy unsigned char _Val through [_First, _Last)
    std::memset(_First, _Val, _Last - _First);
    }

template<class _InIt , class _Ty >

_InIt cliext::find ( _InIt  _First, _InIt  _Last, const _Ty%  _Val  )

inline

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

const char* cliext::find ( const char *  _First, const char *  _Last, int  _Val  )

inline

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

const signed char* cliext::find ( const signed char *  _First, const signed char *  _Last, int  _Val  )

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

const unsigned char* cliext::find ( const unsigned char *  _First, const unsigned char *  _Last, int  _Val  )

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

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

inline

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

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

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

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt1 cliext::find_end_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2  )

inline

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

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

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

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

_FwdIt1 cliext::find_end_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr  _Pred  )

inline

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

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

    if (0 < _Count2)
        for (; _Count2 <= _Count1; ++_First1, --_Count1)
            {   // room for match, try it
            _FwdIt1 _Mid1 = _First1;
            for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1)
                if (!_Pred(*_Mid1, *_Mid2))
                    break;
                else if (++_Mid2 == _Last2)
                    {   // potential answer, save it
                    _Ans = _First1;
                    break;
                    }
            }
    return (_Ans);
    }

template<class _FwdIt1 , class _FwdIt2 >

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

inline

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

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

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

inline

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

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt1 cliext::find_first_of_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2  )

inline

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

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

_FwdIt1 cliext::find_first_of_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr  _Pred  )

inline

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

template<class _InIt , class _Pr >

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

inline

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

template<class _InIt , class _Pr >

_InIt cliext::find_if_unchecked ( _InIt  _First, _InIt  _Last, _Pr  _Pred  )

inline

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

template<class _InIt , class _Ty >

_InIt cliext::find_unchecked ( _InIt  _First, _InIt  _Last, const _Ty%  _Val  )

inline

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

cliext::for

(

)

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

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

cliext::for

(

;;

)

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

        if (_Glast == _First)
            {   // 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 _InIt , class _Fn1 >

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

inline

    {   // perform function for each element
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Func);
    return (cliext::for_each_unchecked(_Unchecked(_First), _Unchecked(_Last),
        _Func));
    }

template<class _InIt , class _Fn1 >

_Fn1 cliext::for_each_unchecked ( _InIt  _First, _InIt  _Last, _Fn1  _Func  )

inline

    {   // perform function for each element
    for (; _First != _Last; ++_First)
        _Func(*_First);
    return (_Func);
    }

template<class _FwdIt , class _Fn0 >

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

inline

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

template<class _OutIt , class _Diff , class _Fn0 >

void cliext::generate_n ( _OutIt  _Dest, _Diff  _Count, _Fn0  _Func  )

inline

    {   // replace [_Dest, _Dest + _Count) with _Func()
    _STLCLRDB_POINTER(_Dest);
    _STLCLRDB_POINTER(_Func);
    cliext::generate_n_unchecked(_Unchecked(_Dest), _Count, _Func);
    }

template<class _OutIt , class _Diff , class _Fn0 >

void cliext::generate_n_unchecked ( _OutIt  _Dest, _Diff  _Count, _Fn0  _Func  )

inline

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

template<class _FwdIt , class _Fn0 >

void cliext::generate_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Fn0  _Func  )

inline

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

template<class _Ty >

pair<_Ty *, std::ptrdiff_t> cliext::get_temporary_buffer ( std::ptrdiff_t  _Count )

inline

    {   // get raw temporary buffer of up to _Count elements
    _Ty *_Pbuf;

    if (_Count < 0)
        _Count = 0;
    for (_Pbuf = 0; 0 < _Count; _Count /= 2)
        try
            {   // try to allocate storage
            _Pbuf = (_Ty *)::operator new(_Count * sizeof (_Ty));
            break;
            }
        catch (...)
            {   // loop if new fails
            }

    return (pair<_Ty *, std::ptrdiff_t>(_Pbuf, _Count));
    }

int cliext::hash_value ( System::Object^  _Key )

inline

    {   // get hash code from object
    return (_Key->GetHashCode());
    }

template<class _InIt1 , class _InIt2 >

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

inline

    {   // test if all [_First1, _Last1) in [_First2, _Last2), using operator<
    _STLCLRDB_ORDER(_First1, _Last1);
    _STLCLRDB_ORDER(_First2, _Last2);
    return (cliext::includes_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2)));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

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

template<class _InIt1 , class _InIt2 >

bool cliext::includes_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2  )

inline

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

template<class _InIt1 , class _InIt2 , class _Pr >

bool cliext::includes_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr  _Pred  )

inline

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

template<class _InIt1 , class _InIt2 , class _Ty >

_Ty cliext::inner_product ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Ty  _Val  )

inline

    {   // return inner product of sequences
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_POINTER(_First2);
    return (cliext::inner_product_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Val));
    }

template<class _InIt1 , class _InIt2 , class _Ty , class _Fn21 , class _Fn22 >

_Ty cliext::inner_product ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Ty  _Val, _Fn21  _Func1, _Fn22  _Func2  )

inline

    {   // return inner product of sequences, using _Func1 and _Func2
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_POINTER(_First2);
    _STLCLRDB_POINTER(_Func1);
    _STLCLRDB_POINTER(_Func2);
    return (cliext::inner_product_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Val, _Func1, _Func2));
    }

template<class _InIt1 , class _InIt2 , class _Ty >

_Ty cliext::inner_product_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Ty  _Val  )

inline

    {   // return inner product of sequences
    for (; _First1 != _Last1; ++_First1, ++_First2)
        _Val = _Val + *_First1 * *_First2;
    return (_Val);
    }

template<class _InIt1 , class _InIt2 , class _Ty , class _Fn21 , class _Fn22 >

_Ty cliext::inner_product_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Ty  _Val, _Fn21  _Func1, _Fn22  _Func2  )

inline

    {   // return inner product of sequences, using _Func1 and _Func2
    for (; _First1 != _Last1; ++_First1, ++_First2)
        _Val = _Func1(_Val, _Func2(*_First1, *_First2));
    return (_Val);
    }

template<class _BidIt >

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

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

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

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<class _BidIt >

void cliext::inplace_merge_unchecked ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last  )

inline

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

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

        cliext::_XBuffered_merge(_First, _Mid, _Last,
            _Count1, _Count2, _Tempbuf);
        }
    }

template<class _BidIt , class _Pr >

void cliext::inplace_merge_unchecked ( _BidIt  _First, _BidIt  _Mid, _BidIt  _Last, _Pr  _Pred  )

inline

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

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

template<class _FwdIt1 , class _FwdIt2 >

void cliext::iter_swap ( _FwdIt1  _Left, _FwdIt2  _Right  )

inline

    {   // swap *_Left and *_Right
    cliext::swap(*_Left, *_Right);
    }

template<class _InIt1 , class _InIt2 >

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

inline

    {   // order [_First1, _Last1) vs. [First2, Last2)
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_RANGE(_First2, _Last2);
    return (cliext::lexicographical_compare_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2)));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

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

inline

    {   // order [_First1, _Last1) vs. [First2, Last2) using _Pred
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_RANGE(_First2, _Last2);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::lexicographical_compare_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Pred));
    }

template<class _InIt1 , class _InIt2 >

bool cliext::lexicographical_compare_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2  )

inline

    {   // order [_First1, _Last1) vs. [First2, Last2)
    for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
        if (_STLCLRDB_LT(*_First1, *_First2))
            return (true);
        else if (*_First2 < *_First1)
            return (false);
    return (_First1 == _Last1 && _First2 != _Last2);
    }

bool cliext::lexicographical_compare_unchecked ( const unsigned char *  _First1, const unsigned char *  _Last1, const unsigned char *  _First2, const unsigned char *  _Last2  )

inline

    {   // order [_First1, _Last1) vs. [First2, Last2), for unsigned char
    std::ptrdiff_t _Num1 = _Last1 - _First1;
    std::ptrdiff_t _Num2 = _Last2 - _First2;
    int _Ans = std::memcmp(_First1, _First2, _Num1 < _Num2 ? _Num1 : _Num2);
    return (_Ans < 0 || _Ans == 0 && _Num1 < _Num2);
    }

bool cliext::lexicographical_compare_unchecked ( const char *  _First1, const char *  _Last1, const char *  _First2, const char *  _Last2  )

inline

    {   // order [_First1, _Last1) vs. [First2, Last2), for nonnegative char
    std::ptrdiff_t _Num1 = _Last1 - _First1;
    std::ptrdiff_t _Num2 = _Last2 - _First2;
    int _Ans = std::memcmp(_First1, _First2, _Num1 < _Num2 ? _Num1 : _Num2);
    return (_Ans < 0 || _Ans == 0 && _Num1 < _Num2);
    }

template<class _InIt1 , class _InIt2 , class _Pr >

bool cliext::lexicographical_compare_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _Pr  _Pred  )

inline

    {   // order [_First1, _Last1) vs. [First2, Last2) using _Pred
    for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2)
        if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
            return (true);
        else if (_Pred(*_First2, *_First1))
            return (false);
    return (_First1 == _Last1 && _First2 != _Last2);
    }

template<class _FwdIt , class _Ty >

_FwdIt cliext::lower_bound ( _FwdIt  _First, _FwdIt  _Last, _Ty%  _Val  )

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

_FwdIt cliext::lower_bound ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val, _Pr  _Pred  )

inline

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

template<class _FwdIt , class _Ty >

_FwdIt cliext::lower_bound_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Ty%  _Val  )

inline

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

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

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

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

template<class _FwdIt , class _Ty , class _Pr >

_FwdIt cliext::lower_bound_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val, _Pr  _Pred  )

inline

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

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

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

template<typename _Iter_t >

range_adapter<_Iter_t> cliext::make_collection ( _Iter_t  _First, _Iter_t  _Last  )

inline

    {   // wrap an iterator pair
    return (gcnew range_adapter<_Iter_t>(_First, _Last));
    }

template<typename _Arg_t >

comparer_less<_Arg_t, System::Collections::Generic::IComparer<_Arg_t> > cliext::make_comparer_less ( System::Collections::Generic::IComparer< _Arg_t >^  _Comp )

inline

    {   // make comparer less from IComparer<T>
    typedef System::Collections::Generic::IComparer<_Arg_t> _Mycomp_t;

    return (gcnew comparer_less<_Arg_t, _Mycomp_t>(_Comp));
    }

comparer_less<System::Object^, System::Collections::IComparer> cliext::make_comparer_less ( System::Collections::IComparer^  _Comp )

inline

    {   // make comparer less from IComparer
    typedef System::Collections::IComparer _Mycomp_t;

    return (gcnew comparer_less<System::Object^, _Mycomp_t>(_Comp));
    }

template<class _RanIt >

void cliext::make_heap ( _RanIt  _First, _RanIt  _Last  )

inline

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

template<class _RanIt , class _Pr >

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

inline

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

template<class _RanIt >

void cliext::make_heap_unchecked ( _RanIt  _First, _RanIt  _Last  )

inline

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

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

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

template<class _RanIt , class _Pr >

void cliext::make_heap_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

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

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

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

template<class _Ty1 , class _Ty2 >

pair<_Ty1, _Ty2> cliext::make_pair ( _Ty1  _Val1, _Ty2  _Val2  )

inline

    {   // return pair composed from arguments
    return (pair<_Ty1, _Ty2>(_Val1, _Val2));
    }

template<class _Ty >

const _Ty() cliext::max ( const _Ty%  _Left, const _Ty%  _Right  )

inline

    {   // return larger of _Left and _Right
    return (_STLCLRDB_LT(_Left, _Right) ? _Right : _Left);
    }

template<class _Ty , class _Pr >

const _Ty() cliext::max ( const _Ty%  _Left, const _Ty%  _Right, _Pr  _Pred  )

inline

    {   // return larger of _Left and _Right using _Pred
    return (_STLCLRDB_LT_PRED(_Pred, _Left, _Right) ? _Right : _Left);
    }

template<class _FwdIt >

_FwdIt cliext::max_element ( _FwdIt  _First, _FwdIt  _Last  )

inline

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

template<class _FwdIt , class _Pr >

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

inline

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

template<class _FwdIt >

_FwdIt cliext::max_element_unchecked ( _FwdIt  _First, _FwdIt  _Last  )

inline

    {   // find largest element, using operator<
    _FwdIt _Found = _First;
    if (_First != _Last)
        for (; ++_First != _Last; )
            if (_STLCLRDB_LT(*_Found, *_First))
                _Found = _First;
    return (_Found);
    }

template<class _FwdIt , class _Pr >

_FwdIt cliext::max_element_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

    {   // find largest element, using _Pred
    _FwdIt _Found = _First;
    if (_First != _Last)
        for (; ++_First != _Last; )
            if (_STLCLRDB_LT_PRED(_Pred, *_Found, *_First))
                _Found = _First;
    return (_Found);
    }

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

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

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

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

inline

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

template<class _InIt1 , class _InIt2 , class _OutIt >

_OutIt cliext::merge_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest  )

inline

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

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

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

_OutIt cliext::merge_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr  _Pred  )

inline

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

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

template<class _Ty >

const _Ty() cliext::min ( const _Ty%  _Left, const _Ty%  _Right  )

inline

    {   // return smaller of _Left and _Right
    return (_STLCLRDB_LT(_Right, _Left) ? _Right : _Left);
    }

template<class _Ty , class _Pr >

const _Ty() cliext::min ( const _Ty%  _Left, const _Ty%  _Right, _Pr  _Pred  )

inline

    {   // return smaller of _Left and _Right using _Pred
    return (_STLCLRDB_LT_PRED(_Pred, _Right, _Left) ? _Right : _Left);
    }

template<class _FwdIt >

_FwdIt cliext::min_element ( _FwdIt  _First, _FwdIt  _Last  )

inline

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

template<class _FwdIt , class _Pr >

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

inline

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

template<class _FwdIt >

_FwdIt cliext::min_element_unchecked ( _FwdIt  _First, _FwdIt  _Last  )

inline

    {   // find smallest element, using operator<
    _FwdIt _Found = _First;
    if (_First != _Last)
        for (; ++_First != _Last; )
            if (_STLCLRDB_LT(*_First, *_Found))
                _Found = _First;
    return (_Found);
    }

template<class _FwdIt , class _Pr >

_FwdIt cliext::min_element_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

    {   // find smallest element, using _Pred
    _FwdIt _Found = _First;
    if (_First != _Last)
        for (; ++_First != _Last; )
            if (_STLCLRDB_LT_PRED(_Pred, *_First, *_Found))
                _Found = _First;
    return (_Found);
    }

template<class _InIt1 , class _InIt2 >

cliext::mismatch ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2  )

inline

    {   // return [_First1, _Last1) and [_First2, _Last2) mismatch
 #if _HAS_ITERATOR_DEBUGGING
    _STLCLRDB_RANGE(_First1, _Last1);
    if (_First1 != _Last1)
        _STLCLRDB_POINTER(_First2);
 #endif /* _HAS_ITERATOR_DEBUGGING */

    return (cliext::mismatch_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2)));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

cliext::mismatch ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr  _Pred  )

inline

    {   // return [_First1, _Last1) and [_First2, _Last2) mismatch using _Pred
 #if _HAS_ITERATOR_DEBUGGING
    _STLCLRDB_RANGE(_First1, _Last1);
    if (_First1 != _Last1)
        _STLCLRDB_POINTER(_First2);
    _STLCLRDB_POINTER(_Pred);
 #endif /* _HAS_ITERATOR_DEBUGGING */

    return (cliext::mismatch_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Pred));
    }

template<class _InIt1 , class _InIt2 >

cliext::mismatch_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2  )

inline

    {   // return [_First1, _Last1) and [_First2, _Last2) mismatch
    for (; _First1 != _Last1 && *_First1 == *_First2; )
        ++_First1, ++_First2;
    return (_PAIR_TYPE2(_InIt1, _InIt2)(_First1, _First2));
    }

template<class _InIt1 , class _InIt2 , class _Pr >

cliext::mismatch_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _Pr  _Pred  )

inline

    {   // return [_First1, _Last1) and [_First2, _Last2) mismatch using _Pred
    for (; _First1 != _Last1 && _Pred(*_First1, *_First2); )
        ++_First1, ++_First2;
    return (_PAIR_TYPE2(_InIt1, _InIt2)(_First1, _First2));
    }

template<class _BidIt >

bool cliext::next_permutation ( _BidIt  _First, _BidIt  _Last  )

inline

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

template<class _BidIt , class _Pr >

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

inline

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

template<class _BidIt >

bool cliext::next_permutation_unchecked ( _BidIt  _First, _BidIt  _Last  )

inline

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

    for (; ; )
        {   // find rightmost element smaller than successor
        _BidIt _Next1 = _Next;
        if (_STLCLRDB_LT(*--_Next, *_Next1))
            {   // swap with rightmost element that's smaller, flip suffix
            _BidIt _Mid = _Last;
            for (; !_STLCLRDB_LT(*_Next, *--_Mid); )
                ;
            cliext::iter_swap(_Next, _Mid);
            cliext::reverse(_Next1, _Last);
            return (true);
            }

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

template<class _BidIt , class _Pr >

bool cliext::next_permutation_unchecked ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred  )

inline

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

    for (; ; )
        {   // find rightmost element smaller than successor
        _BidIt _Next1 = _Next;
        if (_STLCLRDB_LT_PRED(_Pred, *--_Next, *_Next1))
            {   // swap with rightmost element that's smaller, flip suffix
            _BidIt _Mid = _Last;
            for (; !_STLCLRDB_LT_PRED(_Pred, *_Next, *--_Mid); )
                ;
            cliext::iter_swap(_Next, _Mid);
            cliext::reverse(_Next1, _Last);
            return (true);
            }

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

template<typename _Fun_t >

unary_negate<_Fun_t> cliext::not1 ( _Fun_t%  _Func )

inline

    {   // return a unary_negate functor adapter
    return (unary_negate<_Fun_t>(_Func));
    }

template<typename _Fun_t >

binary_negate<_Fun_t> cliext::not2 ( _Fun_t%  _Func )

inline

    {   // return a binary_negate functor adapter
    return (binary_negate<_Fun_t>(_Func));
    }

template<class _RanIt >

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

inline

    {   // order Nth element, using operator<
    _STLCLRDB_RANGE(_First, _Nth);
    _STLCLRDB_RANGE(_Nth, _Last);
    cliext::nth_element_unchecked(
        _Unchecked(_First), _Unchecked(_Nth), _Unchecked(_Last));
    }

template<class _RanIt , class _Pr >

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

inline

    {   // order Nth element, using _Pred
    _STLCLRDB_RANGE(_First, _Nth);
    _STLCLRDB_RANGE(_Nth, _Last);
    _STLCLRDB_POINTER(_Pred);
    cliext::nth_element_unchecked(
        _Unchecked(_First), _Unchecked(_Nth), _Unchecked(_Last), _Pred);
    }

template<class _RanIt >

void cliext::nth_element_unchecked ( _RanIt  _First, _RanIt  _Nth, _RanIt  _Last  )

inline

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

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

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

template<class _RanIt , class _Pr >

void cliext::nth_element_unchecked ( _RanIt  _First, _RanIt  _Nth, _RanIt  _Last, _Pr  _Pred  )

inline

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

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

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

template<class _Ty1 , class _Ty2 >

bool cliext::operator!= ( pair< _Ty1, _Ty2 >%  _Left, pair< _Ty1, _Ty2 >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator!=	(	System::IComparable< _Value_t >^	_Left,
		System::IComparable< _Value_t >^	_Right
	)

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

template<typename _Value_t >

bool cliext::operator!=	(	System::IComparable< _Value_t >%	_Left,
		System::IComparable< _Value_t >%	_Right
	)

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

bool cliext::operator!= ( System::IComparable^  _Left, System::IComparable^  _Right  )

inline

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

bool cliext::operator!= ( System::IComparable%  _Left, System::IComparable%  _Right  )

inline

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

template<typename _Value_t , typename _Cont_t >

bool cliext::operator!=	(	stack< _Value_t, _Cont_t >%	_Left,
		stack< _Value_t, _Cont_t >%	_Right
	)

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

template<typename _Value_t , typename _Cont_t >

bool cliext::operator!= ( queue< _Value_t, _Cont_t >%  _Left, queue< _Value_t, _Cont_t >%  _Right  )

inline

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

template<typename _Traits_t >

bool cliext::operator!= ( cliext::impl::tree< _Traits_t >%  _Left, cliext::impl::tree< _Traits_t >%  _Right  )

inline

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

template<typename _Value_t >

bool cliext::operator!= ( vector< _Value_t >%  _Left, vector< _Value_t >%  _Right  )

inline

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

template<typename _Value_t >

bool cliext::operator!= ( deque< _Value_t >%  _Left, deque< _Value_t >%  _Right  )

inline

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

template<typename _Value_t >

bool cliext::operator!= ( list< _Value_t >%  _Left, list< _Value_t >%  _Right  )

inline

    {   // test if _Left != _Right
    return (!(_Left == _Right));
    }

template<class _Ty1 , class _Ty2 >

bool cliext::operator< ( pair< _Ty1, _Ty2 >%  _Left, pair< _Ty1, _Ty2 >%  _Right  )

inline

    {   // test if _Left < _Right for pairs
    return (_Left.first < _Right.first ||
        !(_Right.first < _Left.first) && _Left.second < _Right.second);
    }

template<typename _Value_t >

bool cliext::operator<	(	System::IComparable< _Value_t >^	_Left,
		System::IComparable< _Value_t >^	_Right
	)

    {   // test if _Left < _Right
    return (_Left->CompareTo(_Right) < 0);
    }

template<typename _Value_t >

bool cliext::operator<	(	System::IComparable< _Value_t >%	_Left,
		System::IComparable< _Value_t >%	_Right
	)

    {   // test if _Left < _Right
    return (_Left.CompareTo((_Value_t)%(System::Object%)_Right) < 0);
    }

bool cliext::operator< ( System::IComparable^  _Left, System::IComparable^  _Right  )

inline

    {   // test if _Left < _Right
    return (_Left->CompareTo(_Right) < 0);
    }

bool cliext::operator< ( System::IComparable%  _Left, System::IComparable%  _Right  )

inline

    {   // test if _Left < _Right
    return (_Left.CompareTo(%(System::Object%)_Right) < 0);
    }

template<typename _Value_t , typename _Cont_t >

bool cliext::operator<	(	stack< _Value_t, _Cont_t >%	_Left,
		stack< _Value_t, _Cont_t >%	_Right
	)

    {   // test if _Left < _Right
    return (*_Left.get_container() < *_Right.get_container());
    }

template<typename _Value_t , typename _Cont_t >

bool cliext::operator< ( queue< _Value_t, _Cont_t >%  _Left, queue< _Value_t, _Cont_t >%  _Right  )

inline

    {   // test if _Left < _Right
    return (*_Left.get_container() < *_Right.get_container());
    }

template<typename _Traits_t >

bool cliext::operator< ( cliext::impl::tree< _Traits_t >%  _Left, cliext::impl::tree< _Traits_t >%  _Right  )

inline

    {   // test if _Left < _Right
    typedef cliext::impl::tree<_Traits_t> _Mytype_t;

    _Mytype_t::size_type _Idx = 0;
    _Mytype_t::node_type^ _Pleft = _Left.front_node();
    _Mytype_t::node_type^ _Pright = _Right.front_node();
    _Mytype_t::key_compare^ _Pred = _Left.key_comp();

    for (; _Idx != _Left.size() && _Idx != _Right.size(); ++_Idx)
        {   // compare next two elements
        if (_Pred(_Left.get_key(_Pleft->_Myval),
            _Right.get_key(_Pright->_Myval)))
            return (true);
        else if (_Pred(_Right.get_key(_Pright->_Myval),
            _Left.get_key(_Pleft->_Myval)))
            return (false);
        _Pleft = _Pleft->next_node();
        _Pright = _Pright->next_node();
        }
    return (_Idx == _Left.size() && _Idx != _Right.size());
    }

template<typename _Value_t >

bool cliext::operator< ( vector< _Value_t >%  _Left, vector< _Value_t >%  _Right  )

inline

    {   // test if _Left < _Right
    vector<_Value_t>::size_type _Idx = 0;

    for (; _Idx != _Left.size() && _Idx != _Right.size(); ++_Idx)
        if (_Left.at(_Idx) < _Right.at(_Idx))
            return (true);
        else if (_Right.at(_Idx) < _Left.at(_Idx))
            return (false);
    return (_Idx == _Left.size() && _Idx != _Right.size());
    }

template<typename _Value_t >

bool cliext::operator< ( deque< _Value_t >%  _Left, deque< _Value_t >%  _Right  )

inline

    {   // test if _Left < _Right
    deque<_Value_t>::size_type _Idx = 0;

    for (; _Idx != _Left.size() && _Idx != _Right.size(); ++_Idx)
        if (_Left.at(_Idx) < _Right.at(_Idx))
            return (true);
        else if (_Right.at(_Idx) < _Left.at(_Idx))
            return (false);
    return (_Idx == _Left.size() && _Idx != _Right.size());
    }

template<typename _Value_t >

bool cliext::operator< ( list< _Value_t >%  _Left, list< _Value_t >%  _Right  )

inline

    {   // test if _Left < _Right
    typedef list<_Value_t> _Mytype_t;

    _Mytype_t::size_type _Idx = 0;
    _Mytype_t::node_type^ _Pleft = _Left.front_node();
    _Mytype_t::node_type^ _Pright = _Right.front_node();

    for (; _Idx != _Left.size() && _Idx != _Right.size(); ++_Idx)
        {   // compare next two elements
        if (_Pleft->_Myval < _Pright->_Myval)
            return (true);
        else if (_Pright->_Myval < _Pleft->_Myval)
            return (false);
        _Pleft = _Pleft->_Next;
        _Pright = _Pright->_Next;
        }
    return (_Idx == _Left.size() && _Idx != _Right.size());
    }

template<class _Ty1 , class _Ty2 >

bool cliext::operator<= ( pair< _Ty1, _Ty2 >%  _Left, pair< _Ty1, _Ty2 >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator<=	(	System::IComparable< _Value_t >^	_Left,
		System::IComparable< _Value_t >^	_Right
	)

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

template<typename _Value_t >

bool cliext::operator<=	(	System::IComparable< _Value_t >%	_Left,
		System::IComparable< _Value_t >%	_Right
	)

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

bool cliext::operator<= ( System::IComparable^  _Left, System::IComparable^  _Right  )

inline

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

bool cliext::operator<= ( System::IComparable%  _Left, System::IComparable%  _Right  )

inline

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

template<typename _Value_t , typename _Cont_t >

bool cliext::operator<=	(	stack< _Value_t, _Cont_t >%	_Left,
		stack< _Value_t, _Cont_t >%	_Right
	)

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

template<typename _Value_t , typename _Cont_t >

bool cliext::operator<= ( queue< _Value_t, _Cont_t >%  _Left, queue< _Value_t, _Cont_t >%  _Right  )

inline

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

template<typename _Traits_t >

bool cliext::operator<= ( cliext::impl::tree< _Traits_t >%  _Left, cliext::impl::tree< _Traits_t >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator<= ( vector< _Value_t >%  _Left, vector< _Value_t >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator<= ( deque< _Value_t >%  _Left, deque< _Value_t >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator<= ( list< _Value_t >%  _Left, list< _Value_t >%  _Right  )

inline

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

template<class _Ty1 , class _Ty2 >

bool cliext::operator== ( pair< _Ty1, _Ty2 >%  _Left, pair< _Ty1, _Ty2 >%  _Right  )

inline

    {   // test for pair equality
    return (_Left.first == _Right.first && _Left.second == _Right.second);
    }

template<typename _Value_t >

bool cliext::operator==	(	System::IComparable< _Value_t >^	_Left,
		System::IComparable< _Value_t >^	_Right
	)

    {   // test if _Left == _Right
    return (_Left->CompareTo(_Right) == 0);
    }

template<typename _Value_t >

bool cliext::operator==	(	System::IComparable< _Value_t >%	_Left,
		System::IComparable< _Value_t >%	_Right
	)

    {   // test if _Left == _Right
    return (_Left.CompareTo((_Value_t)%(System::Object%)_Right) == 0);
    }

bool cliext::operator== ( System::IComparable^  _Left, System::IComparable^  _Right  )

inline

    {   // test if _Left == _Right
    return (_Left->CompareTo(_Right) == 0);
    }

bool cliext::operator== ( System::IComparable%  _Left, System::IComparable%  _Right  )

inline

    {   // test if _Left == _Right
    return (_Left.CompareTo(%(System::Object%)_Right) == 0);
    }

template<typename _Value_t , typename _Cont_t >

bool cliext::operator==	(	stack< _Value_t, _Cont_t >%	_Left,
		stack< _Value_t, _Cont_t >%	_Right
	)

    {   // test if _Left == _Right
    return (*_Left.get_container() == *_Right.get_container());
    }

template<typename _Value_t , typename _Cont_t >

bool cliext::operator== ( queue< _Value_t, _Cont_t >%  _Left, queue< _Value_t, _Cont_t >%  _Right  )

inline

    {   // test if _Left == _Right
    return (*_Left.get_container() == *_Right.get_container());
    }

template<typename _Traits_t >

bool cliext::operator== ( cliext::impl::tree< _Traits_t >%  _Left, cliext::impl::tree< _Traits_t >%  _Right  )

inline

    {   // test if _Left == _Right
    typedef cliext::impl::tree<_Traits_t> _Mytype_t;

    _Mytype_t::size_type _Size = _Left.size();

    if (_Size != _Right.size())
        return (false);
    else
        {   // same length, compare elements
        _Mytype_t::node_type^ _Pleft = _Left.front_node();
        _Mytype_t::node_type^ _Pright = _Right.front_node();
        _Mytype_t::key_compare^ _Pred = _Left.key_comp();

        for (; 0 < _Size; --_Size)
            {   // compare next two elements
                if (_Pred(_Left.get_key(_Pleft->_Myval),
                        _Right.get_key(_Pright->_Myval))
                    || _Pred(_Right.get_key(_Pright->_Myval),
                        _Left.get_key(_Pleft->_Myval)))
                return (false);
            _Pleft = _Pleft->next_node();
            _Pright = _Pright->next_node();
            }
        return (true);
        }
    }

template<typename _Value_t >

bool cliext::operator== ( vector< _Value_t >%  _Left, vector< _Value_t >%  _Right  )

inline

    {   // test if _Left == _Right
    vector<_Value_t>::size_type _Size = _Left.size();

    if (_Size != _Right.size())
        return (false);
    else
        {   // same length, compare elements
        for (int _Idx = 0; _Idx != _Size; ++_Idx)
            if (_Left.at(_Idx) != _Right.at(_Idx))
                return (false);
        return (true);
        }
    }

template<typename _Value_t >

bool cliext::operator== ( deque< _Value_t >%  _Left, deque< _Value_t >%  _Right  )

inline

    {   // test if _Left == _Right
    deque<_Value_t>::size_type _Size = _Left.size();

    if (_Size != _Right.size())
        return (false);
    else
        {   // same length, compare elements
        for (int _Idx = 0; _Idx != _Size; ++_Idx)
            if (_Left.at(_Idx) != _Right.at(_Idx))
                return (false);
        return (true);
        }
    }

template<typename _Value_t >

bool cliext::operator== ( list< _Value_t >%  _Left, list< _Value_t >%  _Right  )

inline

    {   // test if _Left == _Right
    typedef list<_Value_t> _Mytype_t;

    _Mytype_t::size_type _Size = _Left.size();

    if (_Size != _Right.size())
        return (false);
    else
        {   // same length, compare elements
        _Mytype_t::node_type^ _Pleft = _Left.front_node();
        _Mytype_t::node_type^ _Pright = _Right.front_node();

        for (; 0 < _Size; --_Size)
            {   // compare next two elements
            if (_Pleft->_Myval != _Pright->_Myval)
                return (false);
            _Pleft = _Pleft->_Next;
            _Pright = _Pright->_Next;
            }
        return (true);
        }
    }

template<class _Ty1 , class _Ty2 >

bool cliext::operator> ( pair< _Ty1, _Ty2 >%  _Left, pair< _Ty1, _Ty2 >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator>	(	System::IComparable< _Value_t >^	_Left,
		System::IComparable< _Value_t >^	_Right
	)

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

template<typename _Value_t >

bool cliext::operator>	(	System::IComparable< _Value_t >%	_Left,
		System::IComparable< _Value_t >%	_Right
	)

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

bool cliext::operator> ( System::IComparable^  _Left, System::IComparable^  _Right  )

inline

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

bool cliext::operator> ( System::IComparable%  _Left, System::IComparable%  _Right  )

inline

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

template<typename _Value_t , typename _Cont_t >

bool cliext::operator>	(	stack< _Value_t, _Cont_t >%	_Left,
		stack< _Value_t, _Cont_t >%	_Right
	)

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

template<typename _Value_t , typename _Cont_t >

bool cliext::operator> ( queue< _Value_t, _Cont_t >%  _Left, queue< _Value_t, _Cont_t >%  _Right  )

inline

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

template<typename _Traits_t >

bool cliext::operator> ( cliext::impl::tree< _Traits_t >%  _Left, cliext::impl::tree< _Traits_t >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator> ( vector< _Value_t >%  _Left, vector< _Value_t >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator> ( deque< _Value_t >%  _Left, deque< _Value_t >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator> ( list< _Value_t >%  _Left, list< _Value_t >%  _Right  )

inline

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

template<class _Ty1 , class _Ty2 >

bool cliext::operator>= ( pair< _Ty1, _Ty2 >%  _Left, pair< _Ty1, _Ty2 >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator>=	(	System::IComparable< _Value_t >^	_Left,
		System::IComparable< _Value_t >^	_Right
	)

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

template<typename _Value_t >

bool cliext::operator>=	(	System::IComparable< _Value_t >%	_Left,
		System::IComparable< _Value_t >%	_Right
	)

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

bool cliext::operator>= ( System::IComparable^  _Left, System::IComparable^  _Right  )

inline

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

bool cliext::operator>= ( System::IComparable%  _Left, System::IComparable%  _Right  )

inline

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

template<typename _Value_t , typename _Cont_t >

bool cliext::operator>=	(	stack< _Value_t, _Cont_t >%	_Left,
		stack< _Value_t, _Cont_t >%	_Right
	)

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

template<typename _Value_t , typename _Cont_t >

bool cliext::operator>= ( queue< _Value_t, _Cont_t >%  _Left, queue< _Value_t, _Cont_t >%  _Right  )

inline

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

template<typename _Traits_t >

bool cliext::operator>= ( cliext::impl::tree< _Traits_t >%  _Left, cliext::impl::tree< _Traits_t >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator>= ( vector< _Value_t >%  _Left, vector< _Value_t >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator>= ( deque< _Value_t >%  _Left, deque< _Value_t >%  _Right  )

inline

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

template<typename _Value_t >

bool cliext::operator>= ( list< _Value_t >%  _Left, list< _Value_t >%  _Right  )

inline

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

template<class _RanIt >

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

inline

    {   // 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 _RanIt , class _Pr >

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

inline

    {   // 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<class _InIt , class _RanIt >

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

inline

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

template<class _InIt , class _RanIt , class _Pr >

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

inline

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

template<class _InIt , class _RanIt >

_RanIt cliext::partial_sort_copy_unchecked ( _InIt  _First1, _InIt  _Last1, _RanIt  _First2, _RanIt  _Last2  )

inline

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

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

        for (; _First1 != _Last1 && _Mid2 != _Last2; ++_First1, ++_Mid2)
            *_Mid2 = *_First1;  // copy min(_Last1-_First1, _Last2-_First2)
        cliext::make_heap_unchecked(_First2, _Mid2);

        for (; _First1 != _Last1; ++_First1)
            if (_STLCLRDB_LT(*_First1, *_First2))
                cliext::_XAdjust_heap(_First2, _Diff(0),
                    _Diff(_Mid2 - _First2),
                    _Ty(*_First1)); // replace top with new largest

        cliext::sort_heap_unchecked(_First2, _Mid2);
        return (_Mid2);
        }
    }

template<class _InIt , class _RanIt , class _Pr >

_RanIt cliext::partial_sort_copy_unchecked ( _InIt  _First1, _InIt  _Last1, _RanIt  _First2, _RanIt  _Last2, _Pr  _Pred  )

inline

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

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

        for (; _First1 != _Last1 && _Mid2 != _Last2; ++_First1, ++_Mid2)
            *_Mid2 = *_First1;  // copy min(_Last1-_First1, _Last2-_First2)
        cliext::make_heap_unchecked(_First2, _Mid2, _Pred);

        for (; _First1 != _Last1; ++_First1)
            if (_STLCLRDB_LT_PRED(_Pred, *_First1, *_First2))
                cliext::_XAdjust_heap(_First2, _Diff(0),
                    _Diff(_Mid2 - _First2),
                    _Ty(*_First1), _Pred);  // replace top with new largest

        cliext::sort_heap_unchecked(_First2, _Mid2, _Pred);
        return (_Mid2);
        }
    }

template<class _RanIt >

void cliext::partial_sort_unchecked ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last  )

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

void cliext::partial_sort_unchecked ( _RanIt  _First, _RanIt  _Mid, _RanIt  _Last, _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 _InIt , class _OutIt >

_OutIt cliext::partial_sum ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // compute partial sums into _Dest
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::partial_sum_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest)));
    }

template<class _InIt , class _OutIt , class _Fn2 >

_OutIt cliext::partial_sum ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Fn2  _Func  )

inline

    {   // compute partial sums into _Dest, using _Func
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    _STLCLRDB_POINTER(_Func);
    return (cliext::partial_sum_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest), _Func));
    }

template<class _InIt , class _OutIt >

_OutIt cliext::partial_sum_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

    {   // compute partial sums into _Dest
    typedef iterator_traits<_InIt>::value_type _Ty;

    if (_First == _Last)
        return (_Dest);
    else
        {   // compute nontrivial sum
        _Ty _Val = *_First;

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

template<class _InIt , class _OutIt , class _Fn2 >

_OutIt cliext::partial_sum_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Fn2  _Func  )

inline

    {   // compute partial sums into _Dest, using _Func
    typedef iterator_traits<_InIt>::value_type _Ty;

    if (_First == _Last)
        return (_Dest);
    else
        {   // compute nontrivial sum
        _Ty _Val = *_First;

        for (*_Dest = _Val; ++_First != _Last; *++_Dest = _Val)
            _Val = _Func(_Val, *_First);
        return (++_Dest);
        }
    }

template<class _BidIt , class _Pr >

_BidIt cliext::partition ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred  )

inline

    {   // move elements satisfying _Pred to beginning of sequence
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::partition_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Pred));
    }

template<class _BidIt , class _Pr >

_BidIt cliext::partition_unchecked ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred  )

inline

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

        for (; _First != --_Last && !_Pred(*_Last); )
            ;   // skip in-place elements at end
        if (_First == _Last)
            break;  // done

        cliext::iter_swap(_First, _Last);   // swap out-of-place pair and loop
        }
    return (_First);
    }

template<class _RanIt >

void cliext::pop_heap ( _RanIt  _First, _RanIt  _Last  )

inline

    {   // pop *_First to *(_Last - 1) and reheap, using operator<
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_HEAP(_First, _Last);

    if (1 < _Last - _First)
        cliext::pop_heap_unchecked(_Unchecked(_First), _Unchecked(_Last));
    }

template<class _RanIt , class _Pr >

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

inline

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

template<class _RanIt >

void cliext::pop_heap_unchecked ( _RanIt  _First, _RanIt  _Last  )

inline

    {   // pop *_First to *(_Last - 1) and reheap, using operator<
    typedef iterator_traits<_RanIt>::value_type _Ty;

    _XPop_heap(_First, _Last - 1, _Last - 1, _Ty(*(_Last - 1)));
    }

template<class _RanIt , class _Pr >

void cliext::pop_heap_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

    {   // pop *_First to *(_Last - 1) and reheap, using _Pred
    typedef iterator_traits<_RanIt>::value_type _Ty;

    if (1 < _Last - _First)
        _XPop_heap(_First, _Last - 1, _Last - 1, _Ty(*(_Last - 1)), _Pred);
    }

template<class _BidIt >

bool cliext::prev_permutation ( _BidIt  _First, _BidIt  _Last  )

inline

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

template<class _BidIt , class _Pr >

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

inline

    {   // reverse permute and test for pure descending, using _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::prev_permutation_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Pred));
    }

template<class _BidIt >

bool cliext::prev_permutation_unchecked ( _BidIt  _First, _BidIt  _Last  )

inline

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

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

template<class _BidIt , class _Pr >

bool cliext::prev_permutation_unchecked ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred  )

inline

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

    for (; ; )
        {   // find rightmost element not smaller than successor
        _BidIt _Next1 = _Next;
        if (_STLCLRDB_LT_PRED(_Pred, *_Next1, *--_Next))
            {   // swap with rightmost element that's not smaller, flip suffix
            _BidIt _Mid = _Last;
            for (; !_STLCLRDB_LT_PRED(_Pred, *--_Mid, *_Next); )
                ;
            cliext::iter_swap(_Next, _Mid);
            cliext::reverse(_Next1, _Last);
            return (true);
            }

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

template<class _RanIt >

void cliext::push_heap ( _RanIt  _First, _RanIt  _Last  )

inline

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

    _STLCLRDB_RANGE(_First, _Last);
    if (_First != _Last)
        {   // check and push non-empty heap+addition
        _STLCLRDB_HEAP(_First, _Last - 1);
        cliext::push_heap_unchecked(_Unchecked(_First), _Unchecked(_Last));
        }
    }

template<class _RanIt , class _Pr >

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

inline

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

    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    if (_First != _Last)
        {   // 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 _RanIt >

void cliext::push_heap_unchecked ( _RanIt  _First, _RanIt  _Last  )

inline

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

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

template<class _RanIt , class _Pr >

void cliext::push_heap_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

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

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

template<class _RanIt >

void cliext::random_shuffle ( _RanIt  _First, _RanIt  _Last  )

inline

    {   // shuffle [_First, _Last)
    _STLCLRDB_RANGE(_First, _Last);
    cliext::random_shuffle_unchecked(
        _Unchecked(_First), _Unchecked(_Last));
    }

template<class _RanIt , class _Fn1 >

void cliext::random_shuffle ( _RanIt  _First, _RanIt  _Last, _Fn1%  _Func  )

inline

    {   // shuffle [_First, _Last) using random function _Func
    _STLCLRDB_RANGE(_First, _Last);
    cliext::random_shuffle_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Func);
    }

template<class _RanIt >

void cliext::random_shuffle_unchecked ( _RanIt  _First, _RanIt  _Last  )

inline

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

    if (_First != _Last)
        {   // shuffle nontrivial [_First, _Last)
        const int _RANDOM_BITS = 15;    // minimum random bits from _Rand()
        const int _RANDOM_MAX = (1U << _RANDOM_BITS) - 1;

        _RanIt _Next = _First;
        for (unsigned long _Index = 2; ++_Next != _Last; ++_Index)
            {   // assume unsigned long big enough for _Diff count
            unsigned long _Rm = _RANDOM_MAX;
            unsigned long _Rn = _Rand() & _RANDOM_MAX;
            for (; _Rm < _Index && _Rm != ~0UL;
                _Rm = _Rm << _RANDOM_BITS | _RANDOM_MAX)
                _Rn = _Rn << _RANDOM_BITS
                    | (_Rand() & _RANDOM_MAX);  // build random value

            cliext::iter_swap(_Next,
                _First + _Diff(_Rn % _Index));  // swap a pair
            }
        }
    }

template<class _RanIt , class _Fn1 >

void cliext::random_shuffle_unchecked ( _RanIt  _First, _RanIt  _Last, _Fn1%  _Func  )

inline

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

    if (_First != _Last)
        {   // shuffle nonempty [_First, _Last) using random function _Func
        _RanIt _Next = _First;

        for (_Diff _Index = 2; ++_Next != _Last; ++_Index)
            cliext::iter_swap(_Next, _First + _Diff(_Func(_Index)));
        }
    }

template<class _FwdIt , class _Ty >

_FwdIt cliext::remove ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val  )

inline

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

template<class _InIt , class _OutIt , class _Ty >

_OutIt cliext::remove_copy ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, const _Ty%  _Val  )

inline

    {   // copy omitting each matching _Val
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::remove_copy_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest), _Val));
    }

template<class _InIt , class _OutIt , class _Pr >

_OutIt cliext::remove_copy_if ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _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 _InIt , class _OutIt , class _Pr >

_OutIt cliext::remove_copy_if_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr  _Pred  )

inline

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

template<class _InIt , class _OutIt , class _Ty >

_OutIt cliext::remove_copy_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, const _Ty%  _Val  )

inline

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

template<class _FwdIt , class _Pr >

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

inline

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

template<class _FwdIt , class _Pr >

_FwdIt cliext::remove_if_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

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

template<class _FwdIt , class _Ty >

_FwdIt cliext::remove_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val  )

inline

    {   // remove each matching _Val
    _First = cliext::find_unchecked(_First, _Last, _Val);
    if (_First == _Last)
        return (_First);    // empty sequence, all done
    else
        {   // nonempty sequence, worth doing
        _FwdIt _First1 = _First;
        return (cliext::remove_copy(++_First1, _Last, _First, _Val));
        }
    }

template<class _FwdIt , class _Ty >

void cliext::replace ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Oldval, const _Ty%  _Newval  )

inline

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

template<class _InIt , class _OutIt , class _Ty >

_OutIt cliext::replace_copy ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, const _Ty%  _Oldval, const _Ty%  _Newval  )

inline

    {   // copy replacing each matching _Oldval with _Newval
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::replace_copy_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest), _Oldval, _Newval));
    }

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

_OutIt cliext::replace_copy_if ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr  _Pred, const _Ty%  _Val  )

inline

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

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  )

inline

    {   // copy replacing each satisfying _Pred with _Val
    for (; _First != _Last; ++_First, ++_Dest)
        *_Dest = _Pred(*_First) ? _Val : *_First;
    return (_Dest);
    }

template<class _InIt , class _OutIt , class _Ty >

_OutIt cliext::replace_copy_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, const _Ty%  _Oldval, const _Ty%  _Newval  )

inline

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

template<class _FwdIt , class _Pr , class _Ty >

void cliext::replace_if ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred, const _Ty%  _Val  )

inline

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

template<class _FwdIt , class _Pr , class _Ty >

void cliext::replace_if_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred, const _Ty%  _Val  )

inline

    {   // replace each satisfying _Pred with _Val
    for (; _First != _Last; ++_First)
        if (_Pred(*_First))
            *_First = _Val;
    }

template<class _FwdIt , class _Ty >

void cliext::replace_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Oldval, const _Ty%  _Newval  )

inline

    {   // replace each matching _Oldval with _Newval
    for (; _First != _Last; ++_First)
        if (*_First == _Oldval)
            *_First = _Newval;
    }

cliext::return

(

_PAIR_TYPE(_FwdIt)(_First, _First)

)

cliext::return

(

cliext::

equal_range_unchecked_Unchecked(_First), _Unchecked(_Last), _Val

)

cliext::return

(

cliext::

equal_range_unchecked_Unchecked(_First), _Unchecked(_Last), _Val, _Pred

)

template<class _Ty >

void cliext::return_temporary_buffer ( _Ty *  _Pbuf )

inline

    {   // delete raw temporary buffer
    ::operator delete(_Pbuf);
    }

template<class _BidIt >

void cliext::reverse ( _BidIt  _First, _BidIt  _Last  )

inline

    {   // reverse elements in [_First, _Last)
    _STLCLRDB_RANGE(_First, _Last);
    reverse_unchecked(_Unchecked(_First), _Unchecked(_Last));
    }

template<class _BidIt , class _OutIt >

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

inline

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

template<class _BidIt , class _OutIt >

_OutIt cliext::reverse_copy_unchecked ( _BidIt  _First, _BidIt  _Last, _OutIt  _Dest  )

inline

    {   // copy reversing elements in [_First, _Last)
    for (; _First != _Last; ++_Dest)
        *_Dest = *--_Last;
    return (_Dest);
    }

template<class _BidIt >

void cliext::reverse_unchecked ( _BidIt  _First, _BidIt  _Last  )

inline

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

template<class _FwdIt >

void cliext::rotate ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last  )

inline

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

template<class _FwdIt , class _OutIt >

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

inline

    {   // copy rotating [_First, _Last)
    _STLCLRDB_RANGE(_First, _Mid);
    _STLCLRDB_RANGE(_Mid, _Last);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::rotate_copy_unchecked(
        _Unchecked(_First), _Unchecked(_Mid), _Unchecked(_Last),
        _Unchecked(_Dest)));
    }

template<class _FwdIt , class _OutIt >

_OutIt cliext::rotate_copy_unchecked ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last, _OutIt  _Dest  )

inline

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

template<class _FwdIt >

void cliext::rotate_unchecked ( _FwdIt  _First, _FwdIt  _Mid, _FwdIt  _Last  )

inline

    {   // rotate [_First, _Last)
    if (_First != _Mid && _Mid != _Last)
        _Rotate(_First, _Mid, _Last, _Iter_category(_First));
    }

template<class _FwdIt1 , class _FwdIt2 >

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

inline

    {   // find first [_First2, _Last2) match
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_RANGE(_First2, _Last2);
    return (cliext::search_unchecked(_Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2)));
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

_FwdIt1 cliext::search ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _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),
        _Unchecked(_First2), _Unchecked(_Last2), _Pred));
    }

template<class _FwdIt1 , class _Diff2 , class _Ty >

_FwdIt1 cliext::search_n ( _FwdIt1  _First1, _FwdIt1  _Last1, _Diff2  _Count, const _Ty%  _Val  )

inline

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

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

_FwdIt1 cliext::search_n ( _FwdIt1  _First1, _FwdIt1  _Last1, _Diff2  _Count, const _Ty%  _Val, _Pr  _Pred  )

inline

    {   // find first _Count * _Val satisfying _Pred
    _STLCLRDB_RANGE(_First1, _Last1);
    _STLCLRDB_POINTER(_Pred);
    return (_Search_n(_Unchecked(_First1), _Unchecked(_Last1),
        _Count, _Val, _Pred, _Iter_category(_First1)));
    }

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt1 cliext::search_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2  )

inline

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

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

    for (; _Count2 <= _Count1; ++_First1, --_Count1)
        {   // room for match, try it
        _FwdIt1 _Mid1 = _First1;
        for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1, ++_Mid2)
            if (_Mid2 == _Last2)
                return (_First1);
            else if (!(*_Mid1 == *_Mid2))
                break;
        }
    return (_Last1);
    }

template<class _FwdIt1 , class _FwdIt2 , class _Pr >

_FwdIt1 cliext::search_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2, _FwdIt2  _Last2, _Pr  _Pred  )

inline

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

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

    for (; _Count2 <= _Count1; ++_First1, --_Count1)
        {   // room for match, try it
        _FwdIt1 _Mid1 = _First1;
        for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1, ++_Mid2)
            if (_Mid2 == _Last2)
                return (_First1);
            else if (!_Pred(*_Mid1, *_Mid2))
                break;
        }
    return (_Last1);
    }

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

    {   // take set [_First2, _Last2) from [_First1, _Last1), using operator<
    _STLCLRDB_ORDER(_First1, _Last1);
    _STLCLRDB_ORDER(_First2, _Last2);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::set_difference_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest)));
    }

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  )

inline

    {   //  take set [_First2, _Last2) from [_First1, _Last1), using _Pred
    _STLCLRDB_ORDER_PRED(_First1, _Last1, _Pred);
    _STLCLRDB_ORDER_PRED(_First2, _Last2, _Pred);
    _STLCLRDB_POINTER(_Dest);
    return (cliext::set_difference_unchecked(
        _Unchecked(_First1), _Unchecked(_Last1),
        _Unchecked(_First2), _Unchecked(_Last2), _Unchecked(_Dest), _Pred));
    }

template<class _InIt1 , class _InIt2 , class _OutIt >

_OutIt cliext::set_difference_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest  )

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;
        else
            ++_First1, ++_First2;
    return (cliext::copy_unchecked(_First1, _Last1, _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  )

inline

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

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

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

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

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

inline

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

template<class _InIt1 , class _InIt2 , class _OutIt >

_OutIt cliext::set_intersection_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest  )

inline

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

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

_OutIt cliext::set_intersection_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr  _Pred  )

inline

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

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

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

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  )

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<class _InIt1 , class _InIt2 , class _OutIt >

_OutIt cliext::set_symmetric_difference_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest  )

inline

    {   // XOR 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
            ++_First1, ++_First2;
    _Dest = cliext::copy_unchecked(_First1, _Last1, _Dest);
    return (cliext::copy_unchecked(_First2, _Last2, _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  )

inline

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

template<class _InIt1 , class _InIt2 , class _OutIt >

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

inline

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

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  )

inline

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

template<class _InIt1 , class _InIt2 , class _OutIt >

_OutIt cliext::set_union_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest  )

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

_OutIt cliext::set_union_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _InIt2  _Last2, _OutIt  _Dest, _Pr  _Pred  )

inline

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

template<class _RanIt >

void cliext::sort ( _RanIt  _First, _RanIt  _Last  )

inline

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

template<class _RanIt , class _Pr >

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

inline

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

template<class _RanIt >

void cliext::sort_heap ( _RanIt  _First, _RanIt  _Last  )

inline

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

template<class _RanIt , class _Pr >

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

inline

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

template<class _RanIt >

void cliext::sort_heap_unchecked ( _RanIt  _First, _RanIt  _Last  )

inline

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

template<class _RanIt , class _Pr >

void cliext::sort_heap_unchecked ( _RanIt  _First, _RanIt  _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 >

void cliext::sort_unchecked ( _RanIt  _First, _RanIt  _Last  )

inline

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

template<class _RanIt , class _Pr >

void cliext::sort_unchecked ( _RanIt  _First, _RanIt  _Last, _Pr  _Pred  )

inline

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

template<class _BidIt , class _Pr >

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

inline

    {   // partition preserving order of equivalents, using _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::stable_partition_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Pred));

    }

template<class _BidIt , class _Pr >

_BidIt cliext::stable_partition_unchecked ( _BidIt  _First, _BidIt  _Last, _Pr  _Pred  )

inline

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

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

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

template<class _BidIt >

void cliext::stable_sort ( _BidIt  _First, _BidIt  _Last  )

inline

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

template<class _BidIt , class _Pr >

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

inline

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

template<class _BidIt >

void cliext::stable_sort_unchecked ( _BidIt  _First, _BidIt  _Last  )

inline

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

    if (_First != _Last)
        {   // sort nontrivial sequence
        _Diff _Count = 0;
        _Iter_distance(_First, _Last, _Count);
        _TEMP_ITER(_BidIt, _Ty) _Tempbuf((_Count + 1) / 2);

        cliext::_XStable_sort(_First, _Last, _Count, _Tempbuf);
        }
    }

template<class _BidIt , class _Pr >

void cliext::stable_sort_unchecked ( _BidIt  _First, _BidIt  _Last, _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 _Ty1 , class _Ty2 >

void cliext::swap ( pair< _Ty1, _Ty2 >%  _Left, pair< _Ty1, _Ty2 >%  _Right  )

inline

    {   // swap _Left and _Right pairs
    _Left.swap(_Right);
    }

template<class _Ty >

void cliext::swap ( _Ty%  _Left, _Ty%  _Right  )

inline

    {   // exchange values stored at _Left and _Right
    _Ty _Tmp = _Left;
    _Left = _Right, _Right = _Tmp;
    }

template<typename _Key_t >

void cliext::swap ( set< _Key_t >%  _Left, set< _Key_t >%  _Right  )

inline

    {   // swap two sets
    _Left.swap(_Right);
    }

template<typename _Key_t >

void cliext::swap ( cliext::hash_set< _Key_t >%  _Left, cliext::hash_set< _Key_t >%  _Right  )

inline

    {   // swap two hash_sets
    _Left.swap(_Right);
    }

template<typename _Traits_t >

void cliext::swap ( cliext::impl::hash< _Traits_t >%  _Left, cliext::impl::hash< _Traits_t >%  _Right  )

inline

    {   // swap two hash objects
    _Left.swap(_Right);
    }

template<typename _Key_t >

void cliext::swap ( multiset< _Key_t >%  _Left, multiset< _Key_t >%  _Right  )

inline

    {   // swap two multisets
    _Left.swap(_Right);
    }

template<typename _Key_t , typename _Mapped_t >

void cliext::swap ( map< _Key_t, _Mapped_t >%  _Left, map< _Key_t, _Mapped_t >%  _Right  )

inline

    {   // swap two maps
    _Left.swap(_Right);
    }

template<typename _Key_t >

void cliext::swap ( cliext::hash_multiset< _Key_t >%  _Left, cliext::hash_multiset< _Key_t >%  _Right  )

inline

    {   // swap two hash_multisets
    _Left.swap(_Right);
    }

template<typename _Key_t , typename _Mapped_t >

void cliext::swap ( cliext::hash_map< _Key_t, _Mapped_t >%  _Left, cliext::hash_map< _Key_t, _Mapped_t >%  _Right  )

inline

    {   // swap two hash_maps
    _Left.swap(_Right);
    }

template<typename _Traits_t >

void cliext::swap ( cliext::impl::tree< _Traits_t >%  _Left, cliext::impl::tree< _Traits_t >%  _Right  )

inline

    {   // swap two trees
    _Left.swap(_Right);
    }

template<typename _Value_t >

void cliext::swap ( vector< _Value_t >%  _Left, vector< _Value_t >%  _Right  )

inline

    {   // swap two vectors
    _Left.swap(_Right);
    }

template<typename _Value_t >

void cliext::swap ( deque< _Value_t >%  _Left, deque< _Value_t >%  _Right  )

inline

    {   // swap two deques
    _Left.swap(_Right);
    }

template<typename _Value_t >

void cliext::swap ( list< _Value_t >%  _Left, list< _Value_t >%  _Right  )

inline

    {   // swap two lists
    _Left.swap(_Right);
    }

template<typename _Key_t , typename _Mapped_t >

void cliext::swap ( multimap< _Key_t, _Mapped_t >%  _Left, multimap< _Key_t, _Mapped_t >%  _Right  )

inline

    {   // swap two multimaps
    _Left.swap(_Right);
    }

template<typename _Key_t , typename _Mapped_t >

void cliext::swap ( cliext::hash_multimap< _Key_t, _Mapped_t >%  _Left, cliext::hash_multimap< _Key_t, _Mapped_t >%  _Right  )

inline

    {   // swap two hash_multimaps
    _Left.swap(_Right);
    }

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt2 cliext::swap_ranges ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2  )

inline

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

template<class _FwdIt1 , class _FwdIt2 >

_FwdIt2 cliext::swap_ranges_unchecked ( _FwdIt1  _First1, _FwdIt1  _Last1, _FwdIt2  _First2  )

inline

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

template<class _InIt , class _OutIt , class _Fn1 >

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

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<class _InIt1 , class _InIt2 , class _OutIt , class _Fn2 >

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

inline

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

template<class _InIt , class _OutIt , class _Fn1 >

_OutIt cliext::transform_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Fn1  _Func  )

inline

    {   // transform [_First, _Last) with _Func
    for (; _First != _Last; ++_First, ++_Dest)
        *_Dest = _Func(*_First);
    return (_Dest);
    }

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

_OutIt cliext::transform_unchecked ( _InIt1  _First1, _InIt1  _Last1, _InIt2  _First2, _OutIt  _Dest, _Fn2  _Func  )

inline

    {   // transform [_First1, _Last1) and [_First2, _Last2) with _Func
    for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest)
        *_Dest = _Func(*_First1, *_First2);
    return (_Dest);
    }

template<typename TArg , typename TResult >

delegate TResult cliext::unary_delegate

(

TArg

)

template<typename TArg >

delegate void cliext::unary_delegate_noreturn

(

TArg

)

template<class _FwdIt >

_FwdIt cliext::unique ( _FwdIt  _First, _FwdIt  _Last  )

inline

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

template<class _FwdIt , class _Pr >

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

inline

    {   // remove each satisfying _Pred with previous
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Pred);
    return (cliext::unique_unchecked(
        _Unchecked(_First), _Unchecked(_Last), _Pred));
    }

template<class _InIt , class _OutIt >

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

inline

    {   // copy compressing pairs that match
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    return (unique_copy_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest)));
    }

template<class _InIt , class _OutIt , class _Pr >

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

inline

    {   // copy compressing pairs satisfying _Pred
    _STLCLRDB_RANGE(_First, _Last);
    _STLCLRDB_POINTER(_Dest);
    _STLCLRDB_POINTER(_Pred);
    return (unique_copy_unchecked(
        _Unchecked(_First), _Unchecked(_Last),
        _Unchecked(_Dest), _Pred));
    }

template<class _InIt , class _OutIt >

_OutIt cliext::unique_copy_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest  )

inline

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

template<class _InIt , class _OutIt , class _Pr >

_OutIt cliext::unique_copy_unchecked ( _InIt  _First, _InIt  _Last, _OutIt  _Dest, _Pr  _Pred  )

inline

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

template<class _FwdIt >

_FwdIt cliext::unique_unchecked ( _FwdIt  _First, _FwdIt  _Last  )

inline

    {   // remove each matching previous
    for (_FwdIt _Firstb; (_Firstb = _First) != _Last && ++_First != _Last; )
        if (*_Firstb == *_First)
            {   // copy down
            for (; ++_First != _Last; )
                if (!(*_Firstb == *_First))
                    *++_Firstb = *_First;
            return (++_Firstb);
            }
    return (_Last);
    }

template<class _FwdIt , class _Pr >

_FwdIt cliext::unique_unchecked ( _FwdIt  _First, _FwdIt  _Last, _Pr  _Pred  )

inline

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

template<class _FwdIt , class _Ty >

_FwdIt cliext::upper_bound ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val  )

inline

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

template<class _FwdIt , class _Ty , class _Pr >

_FwdIt cliext::upper_bound ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val, _Pr  _Pred  )

inline

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

template<class _FwdIt , class _Ty >

_FwdIt cliext::upper_bound_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val  )

inline

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

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

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

template<class _FwdIt , class _Ty , class _Pr >

_FwdIt cliext::upper_bound_unchecked ( _FwdIt  _First, _FwdIt  _Last, const _Ty%  _Val, _Pr  _Pred  )

inline

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

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

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

cliext::while

(

)

Variable Documentation

_Diff cliext::_Count = 0

_RanIt cliext::_Gfirst = _Plast

_RanIt cliext::_Glast = _Pfirst

template<class _Iter_t >

iterator_traits<_Iter_t>::iterator_category cliext::_Iter_category(_Iter_t)

inline

    {   // return category from iterator argument
    typename iterator_traits<_Iter_t>::iterator_category _Cat;

    return (_Cat);
    }

_RanIt cliext::_Last

Initial value:

{   
    _RanIt _Mid = _First + (_Last - _First) / 2

_RanIt cliext::_Pfirst = _Mid

_RanIt cliext::_Plast = _Pfirst + 1

_RanIt _Pr cliext::_Pred

Initial value:

{   
    typedef iterator_traits<_FwdIt>::difference_type _Diff

_FwdIt const _Ty cliext::_Val

Initial value:

{   
    typedef iterator_traits<_FwdIt>::difference_type _Diff