Namespaces
	__debug

	__detail

	__parallel

	__profile

	chrono

	decimal

	placeholders

	regex_constants

	rel_ops

	this_thread

	tr1

	tr2

Classes
struct	__atomic_base

struct	__atomic_base< _PTp * >

struct	__atomic_flag_base

class	__codecvt_abstract_base

class	__ctype_abstract_base

class	__has_iterator_category_helper

struct	__is_location_invariant

struct	__is_nullptr_t

struct	__numeric_limits_base

struct	_Base_bitset

struct	_Base_bitset< 0 >

struct	_Base_bitset< 1 >

struct	_Bind

struct	_Bind_result

class	_Deque_base

struct	_Deque_iterator

struct	_Enable_copy_move

struct	_Enable_default_constructor

struct	_Enable_destructor

struct	_Enable_special_members

class	_Function_base

struct	_Fwd_list_base

struct	_Fwd_list_const_iterator

struct	_Fwd_list_iterator

struct	_Fwd_list_node

struct	_Fwd_list_node_base

class	_Hashtable

class	_List_base

struct	_List_const_iterator

struct	_List_iterator

struct	_List_node

struct	_Maybe_get_result_type

struct	_Maybe_unary_or_binary_function

struct	_Maybe_unary_or_binary_function< _Res, _T1 >

struct	_Maybe_unary_or_binary_function< _Res, _T1, _T2 >

struct	_Maybe_wrap_member_pointer

struct	_Maybe_wrap_member_pointer< _Tp _Class::* >

class	_Mem_fn< _Res(_Class::*)(_ArgTypes...) const >

class	_Mem_fn< _Res(_Class::*)(_ArgTypes...) const volatile >

class	_Mem_fn< _Res(_Class::*)(_ArgTypes...) volatile >

class	_Mem_fn< _Res(_Class::*)(_ArgTypes...)>

class	_Mu

class	_Mu< _Arg, false, false >

class	_Mu< _Arg, false, true >

class	_Mu< _Arg, true, false >

class	_Mu< reference_wrapper< _Tp >, false, false >

struct	_Placeholder

struct	_Reference_wrapper_base

struct	_Reference_wrapper_base_impl

struct	_Safe_tuple_element

struct	_Safe_tuple_element_impl

struct	_Safe_tuple_element_impl< __i, _Tuple, false >

struct	_Sp_ebo_helper< _Nm, _Tp, false >

struct	_Sp_ebo_helper< _Nm, _Tp, true >

class	_Temporary_buffer

struct	_Tuple_impl

struct	_Tuple_impl< _Idx >

struct	_Tuple_impl< _Idx, _Head, _Tail...>

struct	_Vector_base

struct	_Weak_result_type

struct	_Weak_result_type_impl

struct	_Weak_result_type_impl< _Res(&)(_ArgTypes...)>

struct	_Weak_result_type_impl< _Res(*)(_ArgTypes...)>

struct	_Weak_result_type_impl< _Res(_ArgTypes...)>

struct	_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) const >

struct	_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) const volatile >

struct	_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...) volatile >

struct	_Weak_result_type_impl< _Res(_Class::*)(_ArgTypes...)>

struct	adopt_lock_t

class	allocator

class	allocator< void >

struct	allocator_arg_t

struct	allocator_traits

struct	array

struct	atomic

struct	atomic< _Tp * >

struct	atomic< bool >

struct	atomic< char >

struct	atomic< char16_t >

struct	atomic< char32_t >

struct	atomic< int >

struct	atomic< long >

struct	atomic< long long >

struct	atomic< short >

struct	atomic< signed char >

struct	atomic< unsigned char >

struct	atomic< unsigned int >

struct	atomic< unsigned long >

struct	atomic< unsigned long long >

struct	atomic< unsigned short >

struct	atomic< wchar_t >

struct	atomic_bool

struct	atomic_flag

class	auto_ptr

struct	auto_ptr_ref

class	back_insert_iterator

class	bad_alloc

class	bad_cast

class	bad_exception

class	bad_function_call

class	bad_typeid

class	bad_weak_ptr

class	basic_filebuf

class	basic_fstream

class	basic_ifstream

class	basic_ios

class	basic_iostream

class	basic_istream

class	basic_istringstream

class	basic_ofstream

class	basic_ostream

class	basic_ostringstream

class	basic_regex

class	basic_streambuf

class	basic_string

class	basic_stringbuf

class	basic_stringstream

class	bernoulli_distribution

struct	bidirectional_iterator_tag

struct	binary_function

class	binary_negate

class	binder1st

class	binder2nd

class	binomial_distribution

class	cauchy_distribution

struct	char_traits

struct	char_traits< __gnu_cxx::character< _Value, _Int, _St > >

struct	char_traits< char >

struct	char_traits< wchar_t >

class	chi_squared_distribution

class	codecvt

class	codecvt< _InternT, _ExternT, encoding_state >

class	codecvt< char, char, mbstate_t >

class	codecvt< wchar_t, char, mbstate_t >

class	codecvt_base

class	codecvt_byname

class	collate

class	collate_byname

struct	complex

struct	complex< double >

struct	complex< float >

struct	complex< long double >

class	condition_variable

class	const_mem_fun1_ref_t

class	const_mem_fun1_t

class	const_mem_fun_ref_t

class	const_mem_fun_t

class	ctype

class	ctype< char >

class	ctype< wchar_t >

struct	ctype_base

class	ctype_byname

class	ctype_byname< char >

struct	default_delete

struct	default_delete< _Tp[]>

struct	defer_lock_t

class	deque

class	discard_block_engine

class	discrete_distribution

struct	divides

class	domain_error

class	enable_shared_from_this

struct	equal_to

class	error_category

struct	error_code

struct	error_condition

class	exception

class	exponential_distribution

class	extreme_value_distribution

class	fisher_f_distribution

struct	forward_iterator_tag

class	forward_list

class	fpos

class	front_insert_iterator

class	function< _Res(_ArgTypes...)>

class	future_error

class	gamma_distribution

class	geometric_distribution

struct	greater

struct	greater_equal

class	gslice

class	gslice_array

struct	hash

struct	hash< __debug::bitset< _Nb > >

struct	hash< __debug::vector< bool, _Alloc > >

struct	hash< __gnu_cxx::__u16vstring >

struct	hash< __gnu_cxx::__u32vstring >

struct	hash< __gnu_cxx::__vstring >

struct	hash< __gnu_cxx::__wvstring >

struct	hash< __gnu_cxx::throw_value_limit >

struct	hash< __gnu_cxx::throw_value_random >

struct	hash< __profile::bitset< _Nb > >

struct	hash< __profile::vector< bool, _Alloc > >

struct	hash< __shared_ptr< _Tp, _Lp > >

struct	hash< _Tp * >

struct	hash< bool >

struct	hash< char >

struct	hash< char16_t >

struct	hash< char32_t >

struct	hash< double >

struct	hash< error_code >

struct	hash< float >

struct	hash< int >

struct	hash< long >

struct	hash< long double >

struct	hash< long long >

struct	hash< shared_ptr< _Tp > >

struct	hash< short >

struct	hash< signed char >

struct	hash< string >

struct	hash< thread::id >

struct	hash< type_index >

struct	hash< u16string >

struct	hash< u32string >

struct	hash< unique_ptr< _Tp, _Dp > >

struct	hash< unsigned char >

struct	hash< unsigned int >

struct	hash< unsigned long >

struct	hash< unsigned long long >

struct	hash< unsigned short >

struct	hash< wchar_t >

struct	hash< wstring >

struct	hash<::bitset< _Nb > >

struct	hash<::vector< bool, _Alloc > >

class	independent_bits_engine

class	indirect_array

class	initializer_list

struct	input_iterator_tag

class	insert_iterator

struct	integral_constant

class	invalid_argument

class	ios_base

struct	is_abstract

struct	is_arithmetic

struct	is_array

struct	is_bind_expression

struct	is_bind_expression< _Bind< _Signature > >

struct	is_bind_expression< _Bind_result< _Result, _Signature > >

struct	is_bind_expression< const _Bind< _Signature > >

struct	is_bind_expression< const _Bind_result< _Result, _Signature > >

struct	is_bind_expression< const volatile _Bind< _Signature > >

struct	is_bind_expression< const volatile _Bind_result< _Result, _Signature > >

struct	is_bind_expression< volatile _Bind< _Signature > >

struct	is_bind_expression< volatile _Bind_result< _Result, _Signature > >

struct	is_class

struct	is_compound

struct	is_const

struct	is_empty

struct	is_enum

struct	is_error_code_enum

struct	is_error_code_enum< future_errc >

struct	is_error_condition_enum

struct	is_floating_point

struct	is_function

struct	is_fundamental

struct	is_integral

struct	is_literal_type

struct	is_lvalue_reference

struct	is_member_function_pointer

struct	is_member_object_pointer

struct	is_member_pointer

struct	is_null_pointer

struct	is_object

struct	is_placeholder

struct	is_placeholder< _Placeholder< _Num > >

struct	is_pod

struct	is_pointer

struct	is_polymorphic

struct	is_reference

struct	is_rvalue_reference

struct	is_scalar

struct	is_standard_layout

struct	is_trivial

struct	is_union

struct	is_void

struct	is_volatile

class	istream_iterator

class	istreambuf_iterator

struct	iterator

struct	iterator_traits< _Tp * >

struct	iterator_traits< const _Tp * >

class	length_error

struct	less

struct	less_equal

class	linear_congruential_engine

class	list

class	locale

class	lock_guard

class	logic_error

struct	logical_and

struct	logical_not

struct	logical_or

class	lognormal_distribution

class	map

class	mask_array

class	match_results

class	mem_fun1_ref_t

class	mem_fun1_t

class	mem_fun_ref_t

class	mem_fun_t

class	mersenne_twister_engine

class	messages

struct	messages_base

class	messages_byname

struct	minus

struct	modulus

class	money_base

class	money_get

class	money_put

class	moneypunct

class	moneypunct_byname

class	move_iterator

class	multimap

struct	multiplies

class	multiset

class	mutex

struct	negate

class	negative_binomial_distribution

class	nested_exception

class	normal_distribution

struct	not_equal_to

class	num_get

class	num_put

struct	numeric_limits

struct	numeric_limits< bool >

struct	numeric_limits< char >

struct	numeric_limits< char16_t >

struct	numeric_limits< char32_t >

struct	numeric_limits< double >

struct	numeric_limits< float >

struct	numeric_limits< int >

struct	numeric_limits< long >

struct	numeric_limits< long double >

struct	numeric_limits< long long >

struct	numeric_limits< short >

struct	numeric_limits< signed char >

struct	numeric_limits< unsigned char >

struct	numeric_limits< unsigned int >

struct	numeric_limits< unsigned long >

struct	numeric_limits< unsigned long long >

struct	numeric_limits< unsigned short >

struct	numeric_limits< wchar_t >

class	numpunct

class	numpunct_byname

struct	once_flag

class	ostream_iterator

class	ostreambuf_iterator

class	out_of_range

struct	output_iterator_tag

class	overflow_error

struct	owner_less

struct	owner_less< shared_ptr< _Tp > >

struct	owner_less< weak_ptr< _Tp > >

struct	pair

class	piecewise_constant_distribution

struct	piecewise_construct_t

class	piecewise_linear_distribution

struct	plus

class	pointer_to_binary_function

class	pointer_to_unary_function

struct	pointer_traits

struct	pointer_traits< _Tp * >

class	poisson_distribution

class	priority_queue

class	queue

struct	random_access_iterator_tag

class	random_device

class	range_error

struct	ratio

struct	ratio_equal

struct	ratio_not_equal

class	raw_storage_iterator

class	recursive_mutex

class	reference_wrapper

class	regex_error

class	regex_iterator

class	regex_token_iterator

struct	regex_traits

class	reverse_iterator

class	runtime_error

class	scoped_allocator_adaptor

class	seed_seq

class	set

class	shared_ptr

class	shuffle_order_engine

class	slice

class	slice_array

class	stack

class	student_t_distribution

class	sub_match

class	system_error

class	thread

class	time_base

class	time_get

class	time_get_byname

class	time_put

class	time_put_byname

struct	try_to_lock_t

class	tuple

class	tuple< _T1, _T2 >

class	tuple_element

struct	tuple_element< 0, tuple< _Head, _Tail...> >

struct	tuple_element< __i, tuple< _Head, _Tail...> >

class	tuple_size

struct	tuple_size< tuple< _Elements...> >

struct	type_index

class	type_info

struct	unary_function

class	unary_negate

class	underflow_error

class	uniform_int_distribution

class	uniform_real_distribution

class	unique_lock

class	unique_ptr

class	unique_ptr< _Tp[], _Dp >

class	unordered_map

class	unordered_multimap

class	unordered_multiset

class	unordered_set

struct	uses_allocator

struct	uses_allocator< tuple< _Types...>, _Alloc >

class	valarray

class	vector

class	vector< bool, _Alloc >

class	weak_ptr

class	weibull_distribution

Typedefs
template<typename _Tp >
using	__allocator_base = __gnu_cxx::new_allocator< _Tp >

typedef unsigned char	__atomic_flag_data_type

typedef FILE	__c_file

typedef __locale_t	__c_locale

typedef __gthread_mutex_t	__c_lock

template<typename _Tp , typename _Hash >
using	__cache_default = __not_< __and_< __is_fast_hash< _Hash >, is_default_constructible< _Hash >, is_copy_assignable< _Hash >, __detail::__is_noexcept_hash< _Tp, _Hash >>>

template<typename _From , typename _To >
using	__check_func_return_type = __or_< is_void< _To >, is_convertible< _From, _To >>

typedef __tuple_concater < __ret, __idx, _Tpls...>	__concater

template<typename _Tp >
using	__empty_not_final = typename conditional< __is_final(_Tp), false_type, __is_empty_non_tuple< _Tp >>::type

typedef __make_1st_indices < _Tpls...>::__type	__idx

template<typename _Tp , typename _Tp2 = typename decay<_Tp>::type>
using	__is_socketlike = __or_< is_integral< _Tp2 >, is_enum< _Tp2 >>

template<typename _Bi_iter , typename _Ch_traits , typename _Ch_alloc >
using	__sub_match_string = basic_string< typename iterator_traits< _Bi_iter >::value_type, _Ch_traits, _Ch_alloc >

template<typename _Key , typename _Tp , typename _Hash = hash<_Key>, typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >, typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>>
using	__umap_hashtable = _Hashtable< _Key, std::pair< const _Key, _Tp >, _Alloc, __detail::_Select1st, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr >

template<bool _Cache>
using	__umap_traits = __detail::_Hashtable_traits< _Cache, false, true >

template<typename _Key , typename _Tp , typename _Hash = hash<_Key>, typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >, typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>>
using	__ummap_hashtable = _Hashtable< _Key, std::pair< const _Key, _Tp >, _Alloc, __detail::_Select1st, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr >

template<bool _Cache>
using	__ummap_traits = __detail::_Hashtable_traits< _Cache, false, false >

template<typename _Value , typename _Hash = hash<_Value>, typename _Pred = std::equal_to<_Value>, typename _Alloc = std::allocator<_Value>, typename _Tr = __umset_traits<__cache_default<_Value, _Hash>::value>>
using	__umset_hashtable = _Hashtable< _Value, _Value, _Alloc, __detail::_Identity, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr >

template<bool _Cache>
using	__umset_traits = __detail::_Hashtable_traits< _Cache, true, false >

template<typename _Value , typename _Hash = hash<_Value>, typename _Pred = std::equal_to<_Value>, typename _Alloc = std::allocator<_Value>, typename _Tr = __uset_traits<__cache_default<_Value, _Hash>::value>>
using	__uset_hashtable = _Hashtable< _Value, _Value, _Alloc, __detail::_Identity, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr >

template<bool _Cache>
using	__uset_traits = __detail::_Hashtable_traits< _Cache, true, true >

typedef unsigned long	_Bit_type

template<typename _Tp1 , typename _Tp2 >
using	_NotSame = __not_< is_same< typename std::decay< _Tp1 >::type, typename std::decay< _Tp2 >::type >>

template<typename _InIter >
using	_RequireInputIter = typename enable_if< is_convertible< typename iterator_traits< _InIter >::iterator_category, input_iterator_tag >::value >::type

typedef __atomic_base< char >	atomic_char

typedef __atomic_base< char16_t >	atomic_char16_t

typedef __atomic_base< char32_t >	atomic_char32_t

typedef __atomic_base< int >	atomic_int

typedef __atomic_base < int_fast16_t >	atomic_int_fast16_t

typedef __atomic_base < int_fast32_t >	atomic_int_fast32_t

typedef __atomic_base < int_fast64_t >	atomic_int_fast64_t

typedef __atomic_base < int_fast8_t >	atomic_int_fast8_t

typedef __atomic_base < int_least16_t >	atomic_int_least16_t

typedef __atomic_base < int_least32_t >	atomic_int_least32_t

typedef __atomic_base < int_least64_t >	atomic_int_least64_t

typedef __atomic_base < int_least8_t >	atomic_int_least8_t

typedef __atomic_base< intmax_t >	atomic_intmax_t

typedef __atomic_base< intptr_t >	atomic_intptr_t

typedef __atomic_base< long long >	atomic_llong

typedef __atomic_base< long >	atomic_long

typedef __atomic_base< ptrdiff_t >	atomic_ptrdiff_t

typedef __atomic_base< signed char >	atomic_schar

typedef __atomic_base< short >	atomic_short

typedef __atomic_base< size_t >	atomic_size_t

typedef __atomic_base < unsigned char >	atomic_uchar

typedef __atomic_base < unsigned int >	atomic_uint

typedef __atomic_base < uint_fast16_t >	atomic_uint_fast16_t

typedef __atomic_base < uint_fast32_t >	atomic_uint_fast32_t

typedef __atomic_base < uint_fast64_t >	atomic_uint_fast64_t

typedef __atomic_base < uint_fast8_t >	atomic_uint_fast8_t

typedef __atomic_base < uint_least16_t >	atomic_uint_least16_t

typedef __atomic_base < uint_least32_t >	atomic_uint_least32_t

typedef __atomic_base < uint_least64_t >	atomic_uint_least64_t

typedef __atomic_base < uint_least8_t >	atomic_uint_least8_t

typedef __atomic_base< uintmax_t >	atomic_uintmax_t

typedef __atomic_base< uintptr_t >	atomic_uintptr_t

typedef __atomic_base < unsigned long long >	atomic_ullong

typedef __atomic_base < unsigned long >	atomic_ulong

typedef __atomic_base < unsigned short >	atomic_ushort

typedef __atomic_base< wchar_t >	atomic_wchar_t

typedef match_results< const char * >	cmatch

typedef regex_iterator< const char * >	cregex_iterator

typedef regex_token_iterator < const char * >	cregex_token_iterator

typedef sub_match< const char * >	csub_match

typedef minstd_rand0	default_random_engine

typedef integral_constant < bool, false >	false_type

typedef basic_filebuf< char >	filebuf

typedef basic_fstream< char >	fstream

typedef basic_ifstream< char >	ifstream

typedef basic_ios< char >	ios

typedef basic_iostream< char >	iostream

typedef basic_istream< char >	istream

typedef basic_istringstream< char >	istringstream

typedef shuffle_order_engine < minstd_rand0, 256 >	knuth_b

typedef enum std::memory_order	memory_order

typedef linear_congruential_engine < uint_fast32_t, 48271UL, 0UL, 2147483647UL >	minstd_rand

typedef linear_congruential_engine < uint_fast32_t, 16807UL, 0UL, 2147483647UL >	minstd_rand0

typedef mersenne_twister_engine < uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL >	mt19937

typedef mersenne_twister_engine < uint_fast64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL, 43, 6364136223846793005ULL >	mt19937_64

typedef void(*	new_handler )()

typedef basic_ofstream< char >	ofstream

typedef basic_ostream< char >	ostream

typedef basic_ostringstream< char >	ostringstream

typedef __PTRDIFF_TYPE__	ptrdiff_t

typedef discard_block_engine < ranlux24_base, 223, 23 >	ranlux24

typedef subtract_with_carry_engine < uint_fast32_t, 24, 10, 24 >	ranlux24_base

typedef discard_block_engine < ranlux48_base, 389, 11 >	ranlux48

typedef subtract_with_carry_engine < uint_fast64_t, 48, 5, 12 >	ranlux48_base

template<typename _R1 , typename _R2 >
using	ratio_divide = typename __ratio_divide< _R1, _R2 >::type

template<typename _R1 , typename _R2 >
using	ratio_multiply = typename __ratio_multiply< _R1, _R2 >::type

typedef basic_regex< char >	regex

typedef __SIZE_TYPE__	size_t

typedef match_results < string::const_iterator >	smatch

typedef regex_iterator < string::const_iterator >	sregex_iterator

typedef regex_token_iterator < string::const_iterator >	sregex_token_iterator

typedef sub_match < string::const_iterator >	ssub_match

typedef basic_streambuf< char >	streambuf

typedef long long	streamoff

typedef fpos< mbstate_t >	streampos

typedef ptrdiff_t	streamsize

typedef basic_string< char >	string

typedef basic_stringbuf< char >	stringbuf

typedef basic_stringstream< char >	stringstream

typedef void(*	terminate_handler )()

typedef integral_constant < bool, true >	true_type

typedef fpos< mbstate_t >	u16streampos

typedef basic_string< char16_t >	u16string

typedef fpos< mbstate_t >	u32streampos

typedef basic_string< char32_t >	u32string

typedef void(*	unexpected_handler )()

typedef match_results< const wchar_t * >	wcmatch

typedef regex_iterator< const wchar_t * >	wcregex_iterator

typedef regex_token_iterator < const wchar_t * >	wcregex_token_iterator

typedef sub_match< const wchar_t * >	wcsub_match

typedef basic_filebuf< wchar_t >	wfilebuf

typedef basic_fstream< wchar_t >	wfstream

typedef basic_ifstream< wchar_t >	wifstream

typedef basic_ios< wchar_t >	wios

typedef basic_iostream< wchar_t >	wiostream

typedef basic_istream< wchar_t >	wistream

typedef basic_istringstream < wchar_t >	wistringstream

typedef basic_ofstream< wchar_t >	wofstream

typedef basic_ostream< wchar_t >	wostream

typedef basic_ostringstream < wchar_t >	wostringstream

typedef basic_regex< wchar_t >	wregex

typedef match_results < wstring::const_iterator >	wsmatch

typedef regex_iterator < wstring::const_iterator >	wsregex_iterator

typedef regex_token_iterator < wstring::const_iterator >	wsregex_token_iterator

typedef sub_match < wstring::const_iterator >	wssub_match

typedef basic_streambuf< wchar_t >	wstreambuf

typedef fpos< mbstate_t >	wstreampos

typedef basic_string< wchar_t >	wstring

typedef basic_stringbuf< wchar_t >	wstringbuf

typedef basic_stringstream < wchar_t >	wstringstream

Enumerations
enum	{ _S_threshold }

enum	{ _S_chunk_size }

enum	{ _S_word_bit }

enum	__memory_order_modifier { __memory_order_mask, __memory_order_modifier_mask, __memory_order_hle_acquire, __memory_order_hle_release }

enum	_Ios_Fmtflags { _S_boolalpha, _S_dec, _S_fixed, _S_hex, _S_internal, _S_left, _S_oct, _S_right, _S_scientific, _S_showbase, _S_showpoint, _S_showpos, _S_skipws, _S_unitbuf, _S_uppercase, _S_adjustfield, _S_basefield, _S_floatfield, _S_ios_fmtflags_end }

enum	_Ios_Iostate { _S_goodbit, _S_badbit, _S_eofbit, _S_failbit, _S_ios_iostate_end }

enum	_Ios_Openmode { _S_app, _S_ate, _S_bin, _S_in, _S_out, _S_trunc, _S_ios_openmode_end }

enum	_Ios_Seekdir { _S_beg, _S_cur, _S_end, _S_ios_seekdir_end }

enum	_Manager_operation { __get_type_info, __get_functor_ptr, __clone_functor, __destroy_functor }

enum	_Rb_tree_color { _S_red, _S_black }

enum	cv_status { no_timeout, timeout }

enum	errc { address_family_not_supported, address_in_use, address_not_available, already_connected, argument_list_too_long, argument_out_of_domain, bad_address, bad_file_descriptor, broken_pipe, connection_aborted, connection_already_in_progress, connection_refused, connection_reset, cross_device_link, destination_address_required, device_or_resource_busy, directory_not_empty, executable_format_error, file_exists, file_too_large, filename_too_long, function_not_supported, host_unreachable, illegal_byte_sequence, inappropriate_io_control_operation, interrupted, invalid_argument, invalid_seek, io_error, is_a_directory, message_size, network_down, network_reset, network_unreachable, no_buffer_space, no_child_process, no_lock_available, no_message, no_protocol_option, no_space_on_device, no_such_device_or_address, no_such_device, no_such_file_or_directory, no_such_process, not_a_directory, not_a_socket, not_connected, not_enough_memory, operation_in_progress, operation_not_permitted, operation_not_supported, operation_would_block, permission_denied, protocol_not_supported, read_only_file_system, resource_deadlock_would_occur, resource_unavailable_try_again, result_out_of_range, timed_out, too_many_files_open_in_system, too_many_files_open, too_many_links, too_many_symbolic_link_levels, wrong_protocol_type }

enum	float_denorm_style { denorm_indeterminate, denorm_absent, denorm_present }

enum	float_round_style { round_indeterminate, round_toward_zero, round_to_nearest, round_toward_infinity, round_toward_neg_infinity }

enum	future_errc { future_already_retrieved, promise_already_satisfied, no_state, broken_promise }

enum	future_status { ready, timeout, deferred }

enum	launch { async, deferred }

enum	memory_order { memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst }

Functions
template<typename _CharT >
_CharT *	__add_grouping (_CharT __s, _CharT __sep, const char __gbeg, size_t __gsize, const _CharT __first, const _CharT __last)

template<typename _Tp >
_Tp *	__addressof (_Tp &__r) noexcept

template<typename _ForwardIterator , typename _BinaryPredicate >
_ForwardIterator	__adjacent_find (_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred)

template<typename _RandomAccessIterator , typename _Distance , typename _Tp , typename _Compare >
void	__adjust_heap (_RandomAccessIterator __first, _Distance __holeIndex, _Distance __len, _Tp __value, _Compare __comp)

template<typename _InputIterator , typename _Distance >
void	__advance (_InputIterator &__i, _Distance __n, input_iterator_tag)

template<typename _BidirectionalIterator , typename _Distance >
void	__advance (_BidirectionalIterator &__i, _Distance __n, bidirectional_iterator_tag)

template<typename _RandomAccessIterator , typename _Distance >
void	__advance (_RandomAccessIterator &__i, _Distance __n, random_access_iterator_tag)

template<typename _Alloc >
void	__alloc_on_copy (_Alloc &__one, const _Alloc &__two)

template<typename _Alloc >
_Alloc	__alloc_on_copy (const _Alloc &__a)

template<typename _Alloc >
void	__alloc_on_move (_Alloc &__one, _Alloc &__two)

template<typename _Alloc >
void	__alloc_on_swap (_Alloc &__one, _Alloc &__two)

template<typename _Tp , _Lock_policy _Lp, typename _Alloc , typename... _Args>
__shared_ptr< _Tp, _Lp >	__allocate_shared (const _Alloc &__a, _Args &&...__args)

	__attribute__ ((always_inline)) void atomic_thread_fence(memory_order __m) noexcept

template<typename _Ex >
void	__attribute__ ((__noreturn__))

template<typename _Callable , typename... _Args>
_Bind_simple_helper< _Callable, _Args...>::__type	__bind_simple (_Callable &&__callable, _Args &&...__args)

template<typename _Functor >
_Functor &	__callable_functor (_Functor &__f)

template<typename _Member , typename _Class >
_Mem_fn< _Member _Class::* >	__callable_functor (_Member _Class::*&__p)

template<typename _Member , typename _Class >
_Mem_fn< _Member _Class::* >	__callable_functor (_Member _Class::*const &__p)

template<typename _Member , typename _Class >
_Mem_fn< _Member _Class::* >	__callable_functor (_Member _Class::*volatile &__p)

template<typename _Member , typename _Class >
_Mem_fn< _Member _Class::* >	__callable_functor (_Member _Class::*const volatile &__p)

	__catch (...)

template<typename _Facet >
const _Facet &	__check_facet (const _Facet *__f)

template<typename _RandomAccessIterator , typename _Distance , typename _Compare >
void	__chunk_insertion_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Distance __chunk_size, _Compare __comp)

constexpr memory_order	__cmpexch_failure_order (memory_order __m) noexcept

constexpr memory_order	__cmpexch_failure_order2 (memory_order __m) noexcept

template<typename _Tp >
_Tp	__complex_abs (const complex< _Tp > &__z)

template<typename _Tp >
std::complex< _Tp >	__complex_acos (const std::complex< _Tp > &__z)

template<typename _Tp >
std::complex< _Tp >	__complex_acosh (const std::complex< _Tp > &__z)

template<typename _Tp >
_Tp	__complex_arg (const complex< _Tp > &__z)

template<typename _Tp >
std::complex< _Tp >	__complex_asin (const std::complex< _Tp > &__z)

template<typename _Tp >
std::complex< _Tp >	__complex_asinh (const std::complex< _Tp > &__z)

template<typename _Tp >
std::complex< _Tp >	__complex_atan (const std::complex< _Tp > &__z)

template<typename _Tp >
std::complex< _Tp >	__complex_atanh (const std::complex< _Tp > &__z)

template<typename _Tp >
complex< _Tp >	__complex_cos (const complex< _Tp > &__z)

template<typename _Tp >
complex< _Tp >	__complex_cosh (const complex< _Tp > &__z)

template<typename _Tp >
complex< _Tp >	__complex_exp (const complex< _Tp > &__z)

template<typename _Tp >
complex< _Tp >	__complex_log (const complex< _Tp > &__z)

template<typename _Tp >
complex< _Tp >	__complex_pow (const complex< _Tp > &__x, const complex< _Tp > &__y)

template<typename _Tp >
complex< _Tp >	__complex_pow_unsigned (complex< _Tp > __x, unsigned __n)

template<typename _Tp >
std::complex< _Tp >	__complex_proj (const std::complex< _Tp > &__z)

template<typename _Tp >
complex< _Tp >	__complex_sin (const complex< _Tp > &__z)

template<typename _Tp >
complex< _Tp >	__complex_sinh (const complex< _Tp > &__z)

template<typename _Tp >
complex< _Tp >	__complex_sqrt (const complex< _Tp > &__z)

template<typename _Tp >
complex< _Tp >	__complex_tan (const complex< _Tp > &__z)

template<typename _Tp >
complex< _Tp >	__complex_tanh (const complex< _Tp > &__z)

int	__convert_from_v (const __c_locale &__cloc __attribute__((__unused__)), char __out, const int __size __attribute__((__unused__)), const char __fmt,...)

template<typename _Tp >
void	__convert_to_v (const char *, _Tp &, ios_base::iostate &, const __c_locale &) throw ()

template<>
void	__convert_to_v (const char *, float &, ios_base::iostate &, const __c_locale &) throw ()

template<>
void	__convert_to_v (const char *, double &, ios_base::iostate &, const __c_locale &) throw ()

template<>
void	__convert_to_v (const char *, long double &, ios_base::iostate &, const __c_locale &) throw ()

template<bool _IsMove, typename _II , typename _OI >
_OI	__copy_move_a (_II __first, _II __last, _OI __result)

template<bool _IsMove, typename _CharT >
__gnu_cxx::__enable_if < __is_char< _CharT >::__value, ostreambuf_iterator< _CharT > >::__type	__copy_move_a2 (_CharT __first, _CharT __last, ostreambuf_iterator< _CharT > __result)

template<bool _IsMove, typename _CharT >
__gnu_cxx::__enable_if < __is_char< _CharT >::__value, ostreambuf_iterator< _CharT > >::__type	__copy_move_a2 (const _CharT __first, const _CharT __last, ostreambuf_iterator< _CharT > __result)

template<bool _IsMove, typename _CharT >
__gnu_cxx::__enable_if < __is_char< _CharT >::__value, _CharT * >::__type	__copy_move_a2 (istreambuf_iterator< _CharT > __first, istreambuf_iterator< _CharT > __last, _CharT *__result)

template<bool _IsMove, typename _CharT >
__gnu_cxx::__enable_if < __is_char< _CharT >::__value, ostreambuf_iterator< _CharT, char_traits< _CharT > > >::__type	__copy_move_a2 (_CharT , _CharT , ostreambuf_iterator< _CharT, char_traits< _CharT > >)

template<bool _IsMove, typename _CharT >
__gnu_cxx::__enable_if < __is_char< _CharT >::__value, ostreambuf_iterator< _CharT, char_traits< _CharT > > >::__type	__copy_move_a2 (const _CharT , const _CharT , ostreambuf_iterator< _CharT, char_traits< _CharT > >)

template<bool _IsMove, typename _CharT >
__gnu_cxx::__enable_if < __is_char< _CharT >::__value, _CharT * >::__type	__copy_move_a2 (istreambuf_iterator< _CharT, char_traits< _CharT > >, istreambuf_iterator< _CharT, char_traits< _CharT > >, _CharT *)

template<bool _IsMove, typename _II , typename _OI >
_OI	__copy_move_a2 (_II __first, _II __last, _OI __result)

template<bool _IsMove, typename _BI1 , typename _BI2 >
_BI2	__copy_move_backward_a (_BI1 __first, _BI1 __last, _BI2 __result)

template<bool _IsMove, typename _BI1 , typename _BI2 >
_BI2	__copy_move_backward_a2 (_BI1 __first, _BI1 __last, _BI2 __result)

template<typename _InputIterator , typename _Size , typename _OutputIterator >
_OutputIterator	__copy_n (_InputIterator __first, _Size __n, _OutputIterator __result, input_iterator_tag)

template<typename _RandomAccessIterator , typename _Size , typename _OutputIterator >
_OutputIterator	__copy_n (_RandomAccessIterator __first, _Size __n, _OutputIterator __result, random_access_iterator_tag)

template<typename _CharT , typename _Traits >
streamsize	__copy_streambufs (basic_streambuf< _CharT, _Traits > __sbin, basic_streambuf< _CharT, _Traits > __sbout)

template<typename _CharT , typename _Traits >
streamsize	__copy_streambufs_eof (basic_streambuf< _CharT, _Traits > , basic_streambuf< _CharT, _Traits > , bool &)

template<>
streamsize	__copy_streambufs_eof (basic_streambuf< char > __sbin, basic_streambuf< char > __sbout, bool &__ineof)

template<>
streamsize	__copy_streambufs_eof (basic_streambuf< wchar_t > __sbin, basic_streambuf< wchar_t > __sbout, bool &__ineof)

template<typename _InputIterator , typename _Predicate >
iterator_traits < _InputIterator > ::difference_type	__count_if (_InputIterator __first, _InputIterator __last, _Predicate __pred)

size_t	__deque_buf_size (size_t __size)

template<typename _InputIterator >
iterator_traits < _InputIterator > ::difference_type	__distance (_InputIterator __first, _InputIterator __last, input_iterator_tag)

template<typename _RandomAccessIterator >
iterator_traits < _RandomAccessIterator > ::difference_type	__distance (_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag)

template<typename _Alloc >
void	__do_alloc_on_copy (_Alloc &__one, const _Alloc &__two, true_type)

template<typename _Alloc >
void	__do_alloc_on_copy (_Alloc &, const _Alloc &, false_type)

template<typename _Alloc >
void	__do_alloc_on_move (_Alloc &__one, _Alloc &__two, true_type)

template<typename _Alloc >
void	__do_alloc_on_move (_Alloc &, _Alloc &, false_type)

template<typename _Alloc >
void	__do_alloc_on_swap (_Alloc &__one, _Alloc &__two, true_type)

template<typename _Alloc >
void	__do_alloc_on_swap (_Alloc &, _Alloc &, false_type)

template<typename _Alloc >
auto	__do_outermost (_Alloc &__a, _Alloc *) -> decltype(__a.outer_allocator())

template<typename _Alloc >
_Alloc &	__do_outermost (_Alloc &__a,...)

template<_Lock_policy _Lp, typename _Tp1 , typename _Tp2 >
void	__enable_shared_from_this_helper (const __shared_count< _Lp > &, const __enable_shared_from_this< _Tp1, _Lp > , const _Tp2 ) noexcept

template<typename _Tp1 , typename _Tp2 >
void	__enable_shared_from_this_helper (const __shared_count<> &, const enable_shared_from_this< _Tp1 > , const _Tp2 ) noexcept

template<_Lock_policy _Lp>
void	__enable_shared_from_this_helper (const __shared_count< _Lp > &,...) noexcept

template<typename _II1 , typename _II2 >
bool	__equal_aux (_II1 __first1, _II1 __last1, _II2 __first2)

template<typename _ForwardIterator , typename _Tp , typename _CompareItTp , typename _CompareTpIt >
pair< _ForwardIterator, _ForwardIterator >	__equal_range (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val, _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)

template<typename _ForwardIterator , typename _Tp >
__gnu_cxx::__enable_if <!__is_scalar< _Tp >::__value, void >::__type	__fill_a (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__value)

template<typename _ForwardIterator , typename _Tp >
__gnu_cxx::__enable_if < __is_scalar< _Tp >::__value, void >::__type	__fill_a (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__value)

template<typename _Tp >
__gnu_cxx::__enable_if < __is_byte< _Tp >::__value, void >::__type	__fill_a (_Tp __first, _Tp __last, const _Tp &__c)

void	__fill_bvector (_Bit_iterator __first, _Bit_iterator __last, bool __x)

template<typename _OutputIterator , typename _Size , typename _Tp >
__gnu_cxx::__enable_if <!__is_scalar< _Tp >::__value, _OutputIterator >::__type	__fill_n_a (_OutputIterator __first, _Size __n, const _Tp &__value)

template<typename _OutputIterator , typename _Size , typename _Tp >
__gnu_cxx::__enable_if < __is_scalar< _Tp >::__value, _OutputIterator >::__type	__fill_n_a (_OutputIterator __first, _Size __n, const _Tp &__value)

template<typename _Size , typename _Tp >
__gnu_cxx::__enable_if < __is_byte< _Tp >::__value, _Tp * >::__type	__fill_n_a (_Tp *__first, _Size __n, const _Tp &__c)

template<typename _RandomAccessIterator , typename _Compare >
void	__final_insertion_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _ForwardIterator1 , typename _ForwardIterator2 , typename _BinaryPredicate >
_ForwardIterator1	__find_end (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, forward_iterator_tag, forward_iterator_tag, _BinaryPredicate __comp)

template<typename _BidirectionalIterator1 , typename _BidirectionalIterator2 , typename _BinaryPredicate >
_BidirectionalIterator1	__find_end (_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, bidirectional_iterator_tag, bidirectional_iterator_tag, _BinaryPredicate __comp)

template<typename _InputIterator , typename _Predicate >
_InputIterator	__find_if (_InputIterator __first, _InputIterator __last, _Predicate __pred, input_iterator_tag)

template<typename _RandomAccessIterator , typename _Predicate >
_RandomAccessIterator	__find_if (_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate __pred, random_access_iterator_tag)

template<typename _Iterator , typename _Predicate >
_Iterator	__find_if (_Iterator __first, _Iterator __last, _Predicate __pred)

template<typename _InputIterator , typename _Predicate >
_InputIterator	__find_if_not (_InputIterator __first, _InputIterator __last, _Predicate __pred)

template<typename _InputIterator , typename _Predicate , typename _Distance >
_InputIterator	__find_if_not_n (_InputIterator __first, _Distance &__len, _Predicate __pred)

template<typename _EuclideanRingElement >
_EuclideanRingElement	__gcd (_EuclideanRingElement __m, _EuclideanRingElement __n)

template<std::size_t __i, typename _Head , typename... _Tail>
constexpr __add_ref< _Head >::type	__get_helper (_Tuple_impl< __i, _Head, _Tail...> &__t) noexcept

template<std::size_t __i, typename _Head , typename... _Tail>
constexpr __add_c_ref< _Head > ::type	__get_helper (const _Tuple_impl< __i, _Head, _Tail...> &__t) noexcept

template<typename _Ex >
const nested_exception *	__get_nested_exception (const _Ex &__ex)

mutex &	__get_once_mutex ()

template<typename _RandomAccessIterator , typename _Compare >
void	__heap_select (_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp)

template<typename _Tp >
size_t	__iconv_adaptor (size_t(__func)(iconv_t, _Tp, size_t , char *, size_t ), iconv_t __cd, char *__inbuf, size_t __inbytes, char *__outbuf, size_t __outbytes)

template<typename _InputIterator1 , typename _InputIterator2 , typename _Compare >
bool	__includes (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)

template<typename _BidirectionalIterator , typename _Compare >
void	__inplace_merge (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp)

template<typename _ForwardIterator , typename _Predicate , typename _Distance >
_ForwardIterator	__inplace_stable_partition (_ForwardIterator __first, _Predicate __pred, _Distance __len)

template<typename _RandomAccessIterator , typename _Compare >
void	__inplace_stable_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _RandomAccessIterator , typename _Compare >
void	__insertion_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _CharT , typename _ValueT >
int	__int_to_char (_CharT __bufend, _ValueT __v, const _CharT __lit, ios_base::fmtflags __flags, bool __dec)

template<typename _RandomAccessIterator , typename _Size , typename _Compare >
void	__introselect (_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Size __depth_limit, _Compare __comp)

template<typename _RandomAccessIterator , typename _Size , typename _Compare >
void	__introsort_loop (_RandomAccessIterator __first, _RandomAccessIterator __last, _Size __depth_limit, _Compare __comp)

template<typename _Functor , typename... _Args>
enable_if< (!is_member_pointer < _Functor >::value &&!is_function< _Functor > ::value &&!is_function < typename remove_pointer < _Functor >::type >::value), typename result_of< _Functor &(_Args &&...)>::type >::type	__invoke (_Functor &__f, _Args &&...__args)

template<typename _Functor , typename... _Args>
enable_if< (is_member_pointer < _Functor >::value &&!is_function< _Functor > ::value &&!is_function < typename remove_pointer < _Functor >::type >::value), typename result_of< _Functor(_Args &&...)> ::type >::type	__invoke (_Functor &__f, _Args &&...__args)

template<typename _Functor , typename... _Args>
enable_if< (is_pointer < _Functor >::value &&is_function< typename remove_pointer< _Functor > ::type >::value), typename result_of< _Functor(_Args &&...)> ::type >::type	__invoke (_Functor __f, _Args &&...__args)

template<typename _RandomAccessIterator , typename _Distance >
bool	__is_heap (_RandomAccessIterator __first, _Distance __n)

template<typename _RandomAccessIterator , typename _Compare , typename _Distance >
bool	__is_heap (_RandomAccessIterator __first, _Compare __comp, _Distance __n)

template<typename _RandomAccessIterator >
bool	__is_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)

template<typename _RandomAccessIterator , typename _Compare >
bool	__is_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _RandomAccessIterator , typename _Distance , typename _Compare >
_Distance	__is_heap_until (_RandomAccessIterator __first, _Distance __n, _Compare __comp)

template<typename _ForwardIterator1 , typename _ForwardIterator2 , typename _BinaryPredicate >
bool	__is_permutation (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __pred)

template<typename _ForwardIterator , typename _Compare >
_ForwardIterator	__is_sorted_until (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

template<typename _Iter >
iterator_traits< _Iter > ::iterator_category	__iterator_category (const _Iter &)

template<typename _II1 , typename _II2 >
bool	__lexicographical_compare_aux (_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)

template<typename _II1 , typename _II2 , typename _Compare >
bool	__lexicographical_compare_impl (_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _Compare __comp)

constexpr int	__lg (int __n)

constexpr unsigned	__lg (unsigned __n)

constexpr long	__lg (long __n)

constexpr unsigned long	__lg (unsigned long __n)

constexpr long long	__lg (long long __n)

constexpr unsigned long long	__lg (unsigned long long __n)

template<typename _ForwardIterator , typename _Tp , typename _Compare >
_ForwardIterator	__lower_bound (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val, _Compare __comp)

template<typename _RandomAccessIterator , typename _Compare >
void	__make_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _Iterator , typename _ReturnType = typename conditional<__move_if_noexcept_cond <typename iterator_traits<_Iterator>::value_type>::value, _Iterator, move_iterator<_Iterator>>::type>
_ReturnType	__make_move_if_noexcept_iterator (_Iterator __i)

template<typename _Tp , _Lock_policy _Lp, typename... _Args>
__shared_ptr< _Tp, _Lp >	__make_shared (_Args &&...__args)

template<typename _ForwardIterator , typename _Compare >
_ForwardIterator	__max_element (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

template<typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator , typename _Compare >
_OutputIterator	__merge (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

template<typename _BidirectionalIterator , typename _Distance , typename _Pointer , typename _Compare >
void	__merge_adaptive (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Pointer __buffer, _Distance __buffer_size, _Compare __comp)

template<typename _RandomAccessIterator1 , typename _RandomAccessIterator2 , typename _Distance , typename _Compare >
void	__merge_sort_loop (_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _RandomAccessIterator2 __result, _Distance __step_size, _Compare __comp)

template<typename _RandomAccessIterator , typename _Pointer , typename _Compare >
void	__merge_sort_with_buffer (_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer, _Compare __comp)

template<typename _BidirectionalIterator , typename _Distance , typename _Compare >
void	__merge_without_buffer (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Compare __comp)

template<typename _ForwardIterator , typename _Compare >
_ForwardIterator	__min_element (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

template<typename _ForwardIterator , typename _Compare >
pair< _ForwardIterator, _ForwardIterator >	__minmax_element (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

template<typename _InputIterator1 , typename _InputIterator2 , typename _BinaryPredicate >
pair< _InputIterator1, _InputIterator2 >	__mismatch (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __binary_pred)

template<typename _Iterator >
_Miter_base< _Iterator > ::iterator_type	__miter_base (_Iterator __it)

template<typename _Iterator , typename _Compare >
void	__move_median_to_first (_Iterator __result, _Iterator __a, _Iterator __b, _Iterator __c, _Compare __comp)

template<typename _InputIterator , typename _OutputIterator , typename _Compare >
_OutputIterator	__move_merge (_InputIterator __first1, _InputIterator __last1, _InputIterator __first2, _InputIterator __last2, _OutputIterator __result, _Compare __comp)

template<typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator , typename _Compare >
void	__move_merge_adaptive (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

template<typename _BidirectionalIterator1 , typename _BidirectionalIterator2 , typename _BidirectionalIterator3 , typename _Compare >
void	__move_merge_adaptive_backward (_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BidirectionalIterator3 __result, _Compare __comp)

pointer	__new_finish (__new_start)

pointer	__new_start (this->_M_allocate(__len))

template<typename _BidirectionalIterator , typename _Compare >
bool	__next_permutation (_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)

template<typename _Iterator >
_Niter_base< _Iterator > ::iterator_type	__niter_base (_Iterator __it)

void	__once_proxy (void)

template<typename _CharT , typename _Traits >
void	__ostream_fill (basic_ostream< _CharT, _Traits > &__out, streamsize __n)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	__ostream_insert (basic_ostream< _CharT, _Traits > &__out, const _CharT *__s, streamsize __n)

template<typename _CharT , typename _Traits >
void	__ostream_write (basic_ostream< _CharT, _Traits > &__out, const _CharT *__s, streamsize __n)

template<typename _Alloc >
auto	__outermost (_Alloc &__a) -> decltype(__do_outermost(__a,&__a))

template<typename _RandomAccessIterator , typename _Compare >
void	__partial_sort (_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp)

template<typename _InputIterator , typename _RandomAccessIterator , typename _Compare >
_RandomAccessIterator	__partial_sort_copy (_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)

template<typename _ForwardIterator , typename _Predicate >
_ForwardIterator	__partition (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag)

template<typename _BidirectionalIterator , typename _Predicate >
_BidirectionalIterator	__partition (_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, bidirectional_iterator_tag)

template<typename _RandomAccessIterator , typename _Compare >
void	__pop_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __result, _Compare __comp)

template<typename _BidirectionalIterator , typename _Compare >
bool	__prev_permutation (_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)

template<typename _RandomAccessIterator , typename _Distance , typename _Tp , typename _Compare >
void	__push_heap (_RandomAccessIterator __first, _Distance __holeIndex, _Distance __topIndex, _Tp __value, _Compare __comp)

template<typename _InputIterator , typename _OutputIterator , typename _Predicate >
_OutputIterator	__remove_copy_if (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)

template<typename _ForwardIterator , typename _Predicate >
_ForwardIterator	__remove_if (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)

template<typename _InputIterator , typename _OutputIterator , typename _Predicate , typename _Tp >
_OutputIterator	__replace_copy_if (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred, const _Tp &__new_value)

template<typename _BidirectionalIterator >
void	__reverse (_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag)

template<typename _RandomAccessIterator >
void	__reverse (_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag)

template<typename _ForwardIterator >
void	__rotate (_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, forward_iterator_tag)

template<typename _BidirectionalIterator >
void	__rotate (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, bidirectional_iterator_tag)

template<typename _RandomAccessIterator >
void	__rotate (_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, random_access_iterator_tag)

template<typename _BidirectionalIterator1 , typename _BidirectionalIterator2 , typename _Distance >
_BidirectionalIterator1	__rotate_adaptive (_BidirectionalIterator1 __first, _BidirectionalIterator1 __middle, _BidirectionalIterator1 __last, _Distance __len1, _Distance __len2, _BidirectionalIterator2 __buffer, _Distance __buffer_size)

template<typename _ForwardIterator1 , typename _ForwardIterator2 , typename _BinaryPredicate >
_ForwardIterator1	__search (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __predicate)

template<typename _ForwardIterator , typename _Integer , typename _UnaryPredicate >
_ForwardIterator	__search_n (_ForwardIterator __first, _ForwardIterator __last, _Integer __count, _UnaryPredicate __unary_pred)

template<typename _ForwardIterator , typename _Integer , typename _UnaryPredicate >
_ForwardIterator	__search_n_aux (_ForwardIterator __first, _ForwardIterator __last, _Integer __count, _UnaryPredicate __unary_pred, std::forward_iterator_tag)

template<typename _RandomAccessIter , typename _Integer , typename _UnaryPredicate >
_RandomAccessIter	__search_n_aux (_RandomAccessIter __first, _RandomAccessIter __last, _Integer __count, _UnaryPredicate __unary_pred, std::random_access_iterator_tag)

template<typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator , typename _Compare >
_OutputIterator	__set_difference (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

template<typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator , typename _Compare >
_OutputIterator	__set_intersection (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

void	__set_once_functor_lock_ptr (unique_lock< mutex > *)

template<typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator , typename _Compare >
_OutputIterator	__set_symmetric_difference (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

template<typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator , typename _Compare >
_OutputIterator	__set_union (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

template<typename _RandomAccessIterator , typename _Compare >
void	__sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _RandomAccessIterator , typename _Compare >
void	__sort_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _ForwardIterator , typename _Predicate >
_ForwardIterator	__stable_partition (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)

template<typename _ForwardIterator , typename _Pointer , typename _Predicate , typename _Distance >
_ForwardIterator	__stable_partition_adaptive (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, _Distance __len, _Pointer __buffer, _Distance __buffer_size)

template<typename _RandomAccessIterator , typename _Compare >
void	__stable_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _RandomAccessIterator , typename _Pointer , typename _Distance , typename _Compare >
void	__stable_sort_adaptive (_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer, _Distance __buffer_size, _Compare __comp)

void	__throw_bad_alloc (void) __attribute__((__noreturn__))

void	__throw_bad_cast (void) __attribute__((__noreturn__))

void	__throw_bad_exception (void) __attribute__((__noreturn__))

void	__throw_bad_function_call () __attribute__((__noreturn__))

void	__throw_bad_typeid (void) __attribute__((__noreturn__))

void	__throw_bad_weak_ptr ()

void	__throw_domain_error (const char *) __attribute__((__noreturn__))

void	__throw_future_error (int) __attribute__((__noreturn__))

void	__throw_invalid_argument (const char *) __attribute__((__noreturn__))

void	__throw_ios_failure (const char *) __attribute__((__noreturn__))

void	__throw_length_error (const char *) __attribute__((__noreturn__))

void	__throw_logic_error (const char *) __attribute__((__noreturn__))

void	__throw_out_of_range (const char *) __attribute__((__noreturn__))

void	__throw_out_of_range_fmt (const char *,...) __attribute__((__noreturn__)) __attribute__((__format__(__printf__

void	__throw_overflow_error (const char *) __attribute__((__noreturn__))

void	__throw_range_error (const char *) __attribute__((__noreturn__))

void	__throw_regex_error (regex_constants::error_type __ecode)

void void	__throw_runtime_error (const char *) __attribute__((__noreturn__))

void	__throw_system_error (int) __attribute__((__noreturn__))

void	__throw_underflow_error (const char *) __attribute__((__noreturn__))

template<typename _Ex >
void	__throw_with_nested (_Ex &&,...) __attribute__((__noreturn__))

template<typename _Ex >
void	__throw_with_nested (_Ex &&__ex, const nested_exception *)

template<typename _Lock >
unique_lock< _Lock >	__try_to_lock (_Lock &__l)

template<typename _RandomAccessIterator , typename _Compare >
void	__unguarded_insertion_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _RandomAccessIterator , typename _Compare >
void	__unguarded_linear_insert (_RandomAccessIterator __last, _Compare __comp)

template<typename _RandomAccessIterator , typename _Compare >
_RandomAccessIterator	__unguarded_partition (_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __pivot, _Compare __comp)

template<typename _RandomAccessIterator , typename _Compare >
_RandomAccessIterator	__unguarded_partition_pivot (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _Pointer , typename _ForwardIterator >
void	__uninitialized_construct_buf (_Pointer __first, _Pointer __last, _ForwardIterator __seed)

template<typename _InputIterator , typename _ForwardIterator , typename _Allocator >
_ForwardIterator	__uninitialized_copy_a (_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator &__alloc)

template<typename _InputIterator , typename _ForwardIterator , typename _Tp >
_ForwardIterator	__uninitialized_copy_a (_InputIterator __first, _InputIterator __last, _ForwardIterator __result, allocator< _Tp > &)

template<typename _InputIterator1 , typename _InputIterator2 , typename _ForwardIterator , typename _Allocator >
_ForwardIterator	__uninitialized_copy_move (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _ForwardIterator __result, _Allocator &__alloc)

template<typename _InputIterator , typename _Size , typename _ForwardIterator >
_ForwardIterator	__uninitialized_copy_n (_InputIterator __first, _Size __n, _ForwardIterator __result, input_iterator_tag)

template<typename _RandomAccessIterator , typename _Size , typename _ForwardIterator >
_ForwardIterator	__uninitialized_copy_n (_RandomAccessIterator __first, _Size __n, _ForwardIterator __result, random_access_iterator_tag)

template<typename _ForwardIterator >
void	__uninitialized_default (_ForwardIterator __first, _ForwardIterator __last)

template<typename _ForwardIterator , typename _Allocator >
void	__uninitialized_default_a (_ForwardIterator __first, _ForwardIterator __last, _Allocator &__alloc)

template<typename _ForwardIterator , typename _Tp >
void	__uninitialized_default_a (_ForwardIterator __first, _ForwardIterator __last, allocator< _Tp > &)

template<typename _ForwardIterator , typename _Size >
void	__uninitialized_default_n (_ForwardIterator __first, _Size __n)

template<typename _ForwardIterator , typename _Size , typename _Allocator >
void	__uninitialized_default_n_a (_ForwardIterator __first, _Size __n, _Allocator &__alloc)

template<typename _ForwardIterator , typename _Size , typename _Tp >
void	__uninitialized_default_n_a (_ForwardIterator __first, _Size __n, allocator< _Tp > &)

template<typename _ForwardIterator , typename _Tp , typename _Allocator >
void	__uninitialized_fill_a (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__x, _Allocator &__alloc)

template<typename _ForwardIterator , typename _Tp , typename _Tp2 >
void	__uninitialized_fill_a (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__x, allocator< _Tp2 > &)

template<typename _ForwardIterator , typename _Tp , typename _InputIterator , typename _Allocator >
_ForwardIterator	__uninitialized_fill_move (_ForwardIterator __result, _ForwardIterator __mid, const _Tp &__x, _InputIterator __first, _InputIterator __last, _Allocator &__alloc)

template<typename _ForwardIterator , typename _Size , typename _Tp , typename _Allocator >
void	__uninitialized_fill_n_a (_ForwardIterator __first, _Size __n, const _Tp &__x, _Allocator &__alloc)

template<typename _ForwardIterator , typename _Size , typename _Tp , typename _Tp2 >
void	__uninitialized_fill_n_a (_ForwardIterator __first, _Size __n, const _Tp &__x, allocator< _Tp2 > &)

template<typename _InputIterator , typename _ForwardIterator , typename _Allocator >
_ForwardIterator	__uninitialized_move_a (_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator &__alloc)

template<typename _InputIterator1 , typename _InputIterator2 , typename _ForwardIterator , typename _Allocator >
_ForwardIterator	__uninitialized_move_copy (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _ForwardIterator __result, _Allocator &__alloc)

template<typename _InputIterator , typename _ForwardIterator , typename _Tp , typename _Allocator >
void	__uninitialized_move_fill (_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2, const _Tp &__x, _Allocator &__alloc)

template<typename _InputIterator , typename _ForwardIterator , typename _Allocator >
_ForwardIterator	__uninitialized_move_if_noexcept_a (_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator &__alloc)

template<typename _ForwardIterator , typename _BinaryPredicate >
_ForwardIterator	__unique (_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred)

template<typename _ForwardIterator , typename _OutputIterator , typename _BinaryPredicate >
_OutputIterator	__unique_copy (_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __binary_pred, forward_iterator_tag, output_iterator_tag)

template<typename _InputIterator , typename _OutputIterator , typename _BinaryPredicate >
_OutputIterator	__unique_copy (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __binary_pred, input_iterator_tag, output_iterator_tag)

template<typename _InputIterator , typename _ForwardIterator , typename _BinaryPredicate >
_ForwardIterator	__unique_copy (_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __binary_pred, input_iterator_tag, forward_iterator_tag)

template<typename _Bi_iter >
const sub_match< _Bi_iter > &	__unmatched_sub ()

template<typename _ForwardIterator , typename _Tp , typename _Compare >
_ForwardIterator	__upper_bound (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val, _Compare __comp)

template<typename _Tp , typename _Alloc , typename... _Args>
__uses_alloc_impl< _Tp, _Alloc, _Args...>	__use_alloc (const _Alloc &__a)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __a, _Array< bool > __m, size_t __n, _Array< _Tp > __b, _Array< bool > __k)

template<typename _Tp , class _Dom >
void	__valarray_copy (const _Expr< _Dom, _Tp > &__e, size_t __n, _Array< _Tp > __a)

template<typename _Tp , class _Dom >
void	__valarray_copy (const _Expr< _Dom, _Tp > &__e, size_t __n, _Array< _Tp > __a, size_t __s)

template<typename _Tp , class _Dom >
void	__valarray_copy (const _Expr< _Dom, _Tp > &__e, size_t __n, _Array< _Tp > __a, _Array< size_t > __i)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __e, _Array< size_t > __f, size_t __n, _Array< _Tp > __a, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	__valarray_copy (const _Expr< _Dom, _Tp > &__e, size_t __n, _Array< _Tp > __a, _Array< bool > __m)

template<typename _Tp >
void	__valarray_copy (const _Tp __restrict__ __a, size_t __n, _Tp __restrict__ __b)

template<typename _Tp >
void	__valarray_copy (const _Tp __restrict__ __a, size_t __n, size_t __s, _Tp __restrict__ __b)

template<typename _Tp >
void	__valarray_copy (const _Tp __restrict__ __a, _Tp __restrict__ __b, size_t __n, size_t __s)

template<typename _Tp >
void	__valarray_copy (const _Tp __restrict__ __src, size_t __n, size_t __s1, _Tp __restrict__ __dst, size_t __s2)

template<typename _Tp >
void	__valarray_copy (const _Tp __restrict__ __a, const size_t __restrict__ __i, _Tp *__restrict__ __b, size_t __n)

template<typename _Tp >
void	__valarray_copy (const _Tp __restrict__ __a, size_t __n, _Tp __restrict__ __b, const size_t *__restrict__ __i)

template<typename _Tp >
void	__valarray_copy (const _Tp __restrict__ __src, size_t __n, const size_t __restrict__ __i, _Tp __restrict__ __dst, const size_t __restrict__ __j)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __a, size_t __n, size_t __s1, _Array< _Tp > __b, size_t __s2)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp >
void	__valarray_copy (_Array< _Tp > __src, size_t __n, _Array< size_t > __i, _Array< _Tp > __dst, _Array< size_t > __j)

template<typename _Tp >
void	__valarray_copy_construct (const _Tp __b, const _Tp __e, _Tp *__restrict__ __o)

template<typename _Tp >
void	__valarray_copy_construct (const _Tp __restrict__ __a, size_t __n, size_t __s, _Tp __restrict__ __o)

template<typename _Tp >
void	__valarray_copy_construct (const _Tp __restrict__ __a, const size_t __restrict__ __i, _Tp *__restrict__ __o, size_t __n)

template<typename _Tp , class _Dom >
void	__valarray_copy_construct (const _Expr< _Dom, _Tp > &__e, size_t __n, _Array< _Tp > __a)

template<typename _Tp >
void	__valarray_copy_construct (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	__valarray_copy_construct (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	__valarray_copy_construct (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	__valarray_default_construct (_Tp __b, _Tp __e)

template<typename _Tp >
void	__valarray_destroy_elements (_Tp __b, _Tp __e)

template<typename _Tp >
void	__valarray_fill (_Array< _Tp > __a, size_t __n, _Array< bool > __m, const _Tp &__t)

template<typename _Tp >
void	__valarray_fill (_Tp *__restrict__ __a, size_t __n, const _Tp &__t)

template<typename _Tp >
void	__valarray_fill (_Tp *__restrict__ __a, size_t __n, size_t __s, const _Tp &__t)

template<typename _Tp >
void	__valarray_fill (_Tp __restrict__ __a, const size_t __restrict__ __i, size_t __n, const _Tp &__t)

template<typename _Tp >
void	__valarray_fill (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp >
void	__valarray_fill (_Array< _Tp > __a, size_t __n, size_t __s, const _Tp &__t)

template<typename _Tp >
void	__valarray_fill (_Array< _Tp > __a, _Array< size_t > __i, size_t __n, const _Tp &__t)

template<typename _Tp >
void	__valarray_fill_construct (_Tp __b, _Tp __e, const _Tp __t)

void *	__valarray_get_memory (size_t __n)

template<typename _Tp >
_Tp *__restrict__	__valarray_get_storage (size_t __n)

template<typename _Ta >
_Ta::value_type	__valarray_max (const _Ta &__a)

template<typename _Ta >
_Ta::value_type	__valarray_min (const _Ta &__a)

template<typename _Tp >
_Tp	__valarray_product (const _Tp __f, const _Tp __l)

void	__valarray_release_memory (void *__p)

template<typename _Tp >
_Tp	__valarray_sum (const _Tp __f, const _Tp __l)

bool	__verify_grouping (const char *__grouping, size_t __grouping_size, const string &__grouping_tmp) throw ()

template<typename _CharT >
ostreambuf_iterator< _CharT >	__write (ostreambuf_iterator< _CharT > __s, const _CharT *__ws, int __len)

template<typename _CharT , typename _OutIter >
_OutIter	__write (_OutIter __s, const _CharT *__ws, int __len)

template<typename _Tp >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, size_t __s, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, _Array< size_t > __i, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_and (_Array< _Tp > __a, _Array< bool > __m, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, size_t __s, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, _Array< bool > __m, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, _Array< size_t > __i, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_or (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, _Array< bool > __m, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, size_t __s, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, _Array< size_t > __i, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp , class _Dom >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___bitwise_xor (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___divides (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___divides (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp >
void	_Array_augmented___divides (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp , class _Dom >
void	_Array_augmented___divides (_Array< _Tp > __a, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___divides (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___divides (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp >
void	_Array_augmented___divides (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___divides (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	_Array_augmented___divides (_Array< _Tp > __a, _Array< size_t > __i, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___divides (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp , class _Dom >
void	_Array_augmented___divides (_Array< _Tp > __a, _Array< bool > __m, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp , class _Dom >
void	_Array_augmented___divides (_Array< _Tp > __a, size_t __s, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___minus (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___minus (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp >
void	_Array_augmented___minus (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___minus (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___minus (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp , class _Dom >
void	_Array_augmented___minus (_Array< _Tp > __a, size_t __s, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___minus (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___minus (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	_Array_augmented___minus (_Array< _Tp > __a, _Array< size_t > __i, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___minus (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp , class _Dom >
void	_Array_augmented___minus (_Array< _Tp > __a, _Array< bool > __m, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp , class _Dom >
void	_Array_augmented___minus (_Array< _Tp > __a, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___modulus (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___modulus (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp >
void	_Array_augmented___modulus (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp , class _Dom >
void	_Array_augmented___modulus (_Array< _Tp > __a, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___modulus (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___modulus (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp >
void	_Array_augmented___modulus (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	_Array_augmented___modulus (_Array< _Tp > __a, _Array< size_t > __i, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___modulus (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp , class _Dom >
void	_Array_augmented___modulus (_Array< _Tp > __a, _Array< bool > __m, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___modulus (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp , class _Dom >
void	_Array_augmented___modulus (_Array< _Tp > __a, size_t __s, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___multiplies (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp , class _Dom >
void	_Array_augmented___multiplies (_Array< _Tp > __a, size_t __s, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___multiplies (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp >
void	_Array_augmented___multiplies (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp , class _Dom >
void	_Array_augmented___multiplies (_Array< _Tp > __a, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___multiplies (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___multiplies (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp , class _Dom >
void	_Array_augmented___multiplies (_Array< _Tp > __a, _Array< size_t > __i, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___multiplies (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___multiplies (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp , class _Dom >
void	_Array_augmented___multiplies (_Array< _Tp > __a, _Array< bool > __m, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___multiplies (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	_Array_augmented___plus (_Array< _Tp > __a, size_t __s, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___plus (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___plus (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp >
void	_Array_augmented___plus (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp >
void	_Array_augmented___plus (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp , class _Dom >
void	_Array_augmented___plus (_Array< _Tp > __a, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___plus (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___plus (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp >
void	_Array_augmented___plus (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	_Array_augmented___plus (_Array< _Tp > __a, _Array< size_t > __i, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp , class _Dom >
void	_Array_augmented___plus (_Array< _Tp > __a, _Array< bool > __m, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___plus (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___shift_left (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp , class _Dom >
void	_Array_augmented___shift_left (_Array< _Tp > __a, size_t __s, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___shift_left (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp >
void	_Array_augmented___shift_left (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp , class _Dom >
void	_Array_augmented___shift_left (_Array< _Tp > __a, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___shift_left (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___shift_left (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp >
void	_Array_augmented___shift_left (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___shift_left (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	_Array_augmented___shift_left (_Array< _Tp > __a, _Array< size_t > __i, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___shift_left (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp , class _Dom >
void	_Array_augmented___shift_left (_Array< _Tp > __a, _Array< bool > __m, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp , class _Dom >
void	_Array_augmented___shift_right (_Array< _Tp > __a, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___shift_right (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b)

template<typename _Tp >
void	_Array_augmented___shift_right (_Array< _Tp > __a, _Array< bool > __m, _Array< _Tp > __b, size_t __n)

template<typename _Tp , class _Dom >
void	_Array_augmented___shift_right (_Array< _Tp > __a, _Array< bool > __m, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___shift_right (_Array< _Tp > __a, size_t __n, const _Tp &__t)

template<typename _Tp , class _Dom >
void	_Array_augmented___shift_right (_Array< _Tp > __a, size_t __s, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___shift_right (_Array< _Tp > __a, _Array< size_t > __i, _Array< _Tp > __b, size_t __n)

template<typename _Tp >
void	_Array_augmented___shift_right (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< size_t > __i)

template<typename _Tp , class _Dom >
void	_Array_augmented___shift_right (_Array< _Tp > __a, _Array< size_t > __i, const _Expr< _Dom, _Tp > &__e, size_t __n)

template<typename _Tp >
void	_Array_augmented___shift_right (_Array< _Tp > __a, _Array< _Tp > __b, size_t __n, size_t __s)

template<typename _Tp >
void	_Array_augmented___shift_right (_Array< _Tp > __a, size_t __n, _Array< _Tp > __b, _Array< bool > __m)

template<typename _Tp >
void	_Array_augmented___shift_right (_Array< _Tp > __a, size_t __n, size_t __s, _Array< _Tp > __b)

template<typename _T1 , typename... _Args>
void	_Construct (_T1 *__p, _Args &&...__args)

template<typename _Tp >
void	_Destroy (_Tp *__pointer)

template<typename _ForwardIterator >
void	_Destroy (_ForwardIterator __first, _ForwardIterator __last)

template<typename _ForwardIterator , typename _Allocator >
void	_Destroy (_ForwardIterator __first, _ForwardIterator __last, _Allocator &__alloc)

template<typename _ForwardIterator , typename _Tp >
void	_Destroy (_ForwardIterator __first, _ForwardIterator __last, allocator< _Tp > &)

size_t	_Find_first () const noexcept

size_t	_Find_next (size_t __prev) const noexcept

size_t	_Fnv_hash_bytes (const void *__ptr, size_t __len, size_t __seed)

size_t	_Hash_bytes (const void *__ptr, size_t __len, size_t __seed)

template<class _CharT , class _Traits >
void	_M_copy_from_ptr (const _CharT *, size_t, size_t, size_t, _CharT, _CharT)

template<class _CharT , class _Traits , class _Alloc >
void	_M_copy_from_string (const std::basic_string< _CharT, _Traits, _Alloc > &__s, size_t __pos, size_t __n, _CharT __zero, _CharT __one)

template<class _CharT , class _Traits , class _Alloc >
void	_M_copy_from_string (const std::basic_string< _CharT, _Traits, _Alloc > &__s, size_t __pos, size_t __n)

template<class _CharT , class _Traits , class _Alloc >
void	_M_copy_to_string (std::basic_string< _CharT, _Traits, _Alloc > &, _CharT, _CharT) const

template<class _CharT , class _Traits , class _Alloc >
void	_M_copy_to_string (std::basic_string< _CharT, _Traits, _Alloc > &__s) const

	_M_deallocate (this->_M_impl._M_start, this->_M_impl._M_end_of_storage-this->_M_impl._M_start)

template<size_t _Nb>
	_M_do_and (__rhs)

__tmp	_M_hook (__position._M_const_cast()._M_node)

return	_M_insert_ (__res.first, __res.second, std::forward< _Arg >(__v))

else return	_M_insert_aux (__position._M_const_cast(), __x)

return	_M_insert_equal_lower (std::forward< _Arg >(__v))

return	_M_insert_lower (__y, std::forward< _Arg >(__v))

	_M_leftmost ()

	_M_rightmost ()

	_M_root () -> _M_parent=_M_end()

this _M_impl _M_finish	_M_set_node (this->_M_impl._M_finish._M_node+1)

template<typename _Key , typename _Value , typename _Alloc , typename _ExtractKey , typename _Equal , typename _H1 , typename _H2 , typename _Hash , typename _RehashPolicy , typename _Traits >
void _Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >this	_M_swap (__x)

template<typename _Key , typename _Val , typename _KeyOfValue , typename _Compare , typename _Alloc >
void	_Rb_tree< _Key, _Val, _KeyOfValue, _Compare, _Alloc >_M_root ()

unsigned int	_Rb_tree_black_count (const _Rb_tree_node_base __node, const _Rb_tree_node_base __root) throw ()

_Rb_tree_node_base *	_Rb_tree_decrement (_Rb_tree_node_base *__x) throw ()

const _Rb_tree_node_base *	_Rb_tree_decrement (const _Rb_tree_node_base *__x) throw ()

_Rb_tree_node_base *	_Rb_tree_increment (_Rb_tree_node_base *__x) throw ()

const _Rb_tree_node_base *	_Rb_tree_increment (const _Rb_tree_node_base *__x) throw ()

void	_Rb_tree_insert_and_rebalance (const bool __insert_left, _Rb_tree_node_base __x, _Rb_tree_node_base __p, _Rb_tree_node_base &__header) throw ()

	_Rb_tree_insert_and_rebalance (__insert_left, __z, __p, this->_M_impl._M_header)

_Rb_tree_node_base *	_Rb_tree_rebalance_for_erase (_Rb_tree_node_base *const __z, _Rb_tree_node_base &__header) throw ()

return	_Res (_M_insert_(__res.first, __res.second, std::forward< _Arg >(__v)), true)

return	_Res (iterator(static_cast< _Link_type >(__res.first)), false)

void	abort (void) throw ()

template<typename _Tp >
_Tp	abs (const complex< _Tp > &)

constexpr double	abs (double __x)

constexpr float	abs (float __x)

constexpr long double	abs (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	abs (_Tp __x)

template<typename _Tp >
_Expr< _UnClos< _Abs, _ValArray, _Tp >, _Tp >	abs (const valarray< _Tp > &__v)

template<class _Dom >
_Expr< _UnClos< _Abs, _Expr, _Dom >, typename _Dom::value_type >	abs (const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _InputIterator , typename _Tp >
_Tp	accumulate (_InputIterator __first, _InputIterator __last, _Tp __init)

template<typename _InputIterator , typename _Tp , typename _BinaryOperation >
_Tp	accumulate (_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op)

constexpr float	acos (float __x)

constexpr long double	acos (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	acos (_Tp __x)

template<class _Dom >
_Expr< _UnClos< _Acos, _Expr, _Dom >, typename _Dom::value_type >	acos (const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _UnClos< _Acos, _ValArray, _Tp >, _Tp >	acos (const valarray< _Tp > &__v)

template<typename _Tp >
std::complex< _Tp >	acos (const std::complex< _Tp > &__z)

template<typename _Tp >
std::complex< _Tp >	acosh (const std::complex< _Tp > &__z)

template<typename _Tp >
_Tp *	addressof (_Tp &__r) noexcept

template<typename _InputIterator , typename _OutputIterator >
_OutputIterator	adjacent_difference (_InputIterator __first, _InputIterator __last, _OutputIterator __result)

template<typename _InputIterator , typename _OutputIterator , typename _BinaryOperation >
_OutputIterator	adjacent_difference (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op)

template<typename _FIter >
_FIter	adjacent_find (_FIter, _FIter)

template<typename _FIter , typename _BinaryPredicate >
_FIter	adjacent_find (_FIter, _FIter, _BinaryPredicate)

template<typename _ForwardIterator >
_ForwardIterator	adjacent_find (_ForwardIterator __first, _ForwardIterator __last)

template<typename _ForwardIterator , typename _BinaryPredicate >
_ForwardIterator	adjacent_find (_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred)

template<typename _InputIterator , typename _Distance >
void	advance (_InputIterator &__i, _Distance __n)

bool	all () const noexcept

template<typename _IIter , typename _Predicate >
bool	all_of (_IIter, _IIter, _Predicate)

template<typename _InputIterator , typename _Predicate >
bool	all_of (_InputIterator __first, _InputIterator __last, _Predicate __pred)

template<typename _Tp , typename _Alloc , typename... _Args>
shared_ptr< _Tp >	allocate_shared (const _Alloc &__a, _Args &&...__args)

bool	any () const noexcept

template<typename _IIter , typename _Predicate >
bool	any_of (_IIter, _IIter, _Predicate)

template<typename _InputIterator , typename _Predicate >
bool	any_of (_InputIterator __first, _InputIterator __last, _Predicate __pred)

template<typename _Tp >
_Tp	arg (const complex< _Tp > &)

template<typename _Tp >
__gnu_cxx::__promote< _Tp >::__type	arg (_Tp __x)

constexpr float	asin (float __x)

constexpr long double	asin (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	asin (_Tp __x)

template<class _Dom >
_Expr< _UnClos< _Asin, _Expr, _Dom >, typename _Dom::value_type >	asin (const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _UnClos< _Asin, _ValArray, _Tp >, _Tp >	asin (const valarray< _Tp > &__v)

template<typename _Tp >
std::complex< _Tp >	asin (const std::complex< _Tp > &__z)

template<typename _Tp >
std::complex< _Tp >	asinh (const std::complex< _Tp > &__z)

template<typename _Fn , typename... _Args>
future< typename result_of < _Fn(_Args...)>::type >	async (launch __policy, _Fn &&__fn, _Args &&...__args)

template<typename _Fn , typename... _Args>
future< typename result_of < _Fn(_Args...)>::type >	async (_Fn &&__fn, _Args &&...__args)

constexpr float	atan (float __x)

constexpr long double	atan (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	atan (_Tp __x)

template<class _Dom >
_Expr< _UnClos< _Atan, _Expr, _Dom >, typename _Dom::value_type >	atan (const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _UnClos< _Atan, _ValArray, _Tp >, _Tp >	atan (const valarray< _Tp > &__v)

template<typename _Tp >
std::complex< _Tp >	atan (const std::complex< _Tp > &__z)

constexpr float	atan2 (float __y, float __x)

constexpr long double	atan2 (long double __y, long double __x)

template<typename _Tp , typename _Up >
constexpr __gnu_cxx::__promote_2< _Tp, _Up >::__type	atan2 (_Tp __y, _Up __x)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< _Atan2, _Expr, _Expr, _Dom1, _Dom2 > , typename _Dom1::value_type >	atan2 (const _Expr< _Dom1, typename _Dom1::value_type > &__e1, const _Expr< _Dom2, typename _Dom2::value_type > &__e2)

template<class _Dom >
_Expr< _BinClos< _Atan2, _Expr, _ValArray, _Dom, typename _Dom::value_type >, typename _Dom::value_type >	atan2 (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< _Atan2, _Expr, _Constant, _Dom, typename _Dom::value_type >, typename _Dom::value_type >	atan2 (const _Expr< _Dom, typename _Dom::value_type > &__e, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos< _Atan2, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename _Dom::value_type >	atan2 (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _BinClos< _Atan2, _ValArray, _ValArray, _Tp, _Tp > , _Tp >	atan2 (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<typename _Tp >
_Expr< _BinClos< _Atan2, _ValArray, _Constant, _Tp, _Tp > , _Tp >	atan2 (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< _Atan2, _Constant, _ValArray, _Tp, _Tp > , _Tp >	atan2 (const _Tp &__t, const valarray< _Tp > &__v)

template<class _Dom >
_Expr< _BinClos< _Atan2, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename _Dom::value_type >	atan2 (const valarray< typename _Dom::valarray > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
std::complex< _Tp >	atanh (const std::complex< _Tp > &__z)

int	atexit (void(*)(void)) throw ()

template<typename _ITp >
bool	atomic_compare_exchange_strong (atomic< _ITp > __a, _ITp __i1, _ITp __i2) noexcept

template<typename _ITp >
bool	atomic_compare_exchange_strong (volatile atomic< _ITp > __a, _ITp __i1, _ITp __i2) noexcept

template<typename _ITp >
bool	atomic_compare_exchange_strong_explicit (atomic< _ITp > __a, _ITp __i1, _ITp __i2, memory_order __m1, memory_order __m2) noexcept

template<typename _ITp >
bool	atomic_compare_exchange_strong_explicit (volatile atomic< _ITp > __a, _ITp __i1, _ITp __i2, memory_order __m1, memory_order __m2) noexcept

template<typename _ITp >
bool	atomic_compare_exchange_weak (atomic< _ITp > __a, _ITp __i1, _ITp __i2) noexcept

template<typename _ITp >
bool	atomic_compare_exchange_weak (volatile atomic< _ITp > __a, _ITp __i1, _ITp __i2) noexcept

template<typename _ITp >
bool	atomic_compare_exchange_weak_explicit (atomic< _ITp > __a, _ITp __i1, _ITp __i2, memory_order __m1, memory_order __m2) noexcept

template<typename _ITp >
bool	atomic_compare_exchange_weak_explicit (volatile atomic< _ITp > __a, _ITp __i1, _ITp __i2, memory_order __m1, memory_order __m2) noexcept

template<typename _ITp >
_ITp	atomic_exchange (atomic< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp	atomic_exchange (volatile atomic< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp	atomic_exchange_explicit (atomic< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_exchange_explicit (volatile atomic< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_fetch_add (__atomic_base< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp	atomic_fetch_add (volatile __atomic_base< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp *	atomic_fetch_add (volatile atomic< _ITp * > *__a, ptrdiff_t __d) noexcept

template<typename _ITp >
_ITp *	atomic_fetch_add (atomic< _ITp * > *__a, ptrdiff_t __d) noexcept

template<typename _ITp >
_ITp	atomic_fetch_add_explicit (__atomic_base< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_fetch_add_explicit (volatile __atomic_base< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp *	atomic_fetch_add_explicit (atomic< _ITp * > *__a, ptrdiff_t __d, memory_order __m) noexcept

template<typename _ITp >
_ITp *	atomic_fetch_add_explicit (volatile atomic< _ITp * > *__a, ptrdiff_t __d, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_fetch_and (__atomic_base< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp	atomic_fetch_and (volatile __atomic_base< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp	atomic_fetch_and_explicit (__atomic_base< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_fetch_and_explicit (volatile __atomic_base< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_fetch_or (__atomic_base< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp	atomic_fetch_or (volatile __atomic_base< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp	atomic_fetch_or_explicit (__atomic_base< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_fetch_or_explicit (volatile __atomic_base< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_fetch_sub (__atomic_base< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp	atomic_fetch_sub (volatile __atomic_base< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp *	atomic_fetch_sub (volatile atomic< _ITp * > *__a, ptrdiff_t __d) noexcept

template<typename _ITp >
_ITp *	atomic_fetch_sub (atomic< _ITp * > *__a, ptrdiff_t __d) noexcept

template<typename _ITp >
_ITp	atomic_fetch_sub_explicit (__atomic_base< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_fetch_sub_explicit (volatile __atomic_base< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp *	atomic_fetch_sub_explicit (volatile atomic< _ITp * > *__a, ptrdiff_t __d, memory_order __m) noexcept

template<typename _ITp >
_ITp *	atomic_fetch_sub_explicit (atomic< _ITp * > *__a, ptrdiff_t __d, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_fetch_xor (__atomic_base< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp	atomic_fetch_xor (volatile __atomic_base< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
_ITp	atomic_fetch_xor_explicit (__atomic_base< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_fetch_xor_explicit (volatile __atomic_base< _ITp > *__a, _ITp __i, memory_order __m) noexcept

void	atomic_flag_clear (atomic_flag *__a) noexcept

void	atomic_flag_clear (volatile atomic_flag *__a) noexcept

void	atomic_flag_clear_explicit (atomic_flag *__a, memory_order __m) noexcept

void	atomic_flag_clear_explicit (volatile atomic_flag *__a, memory_order __m) noexcept

bool	atomic_flag_test_and_set (atomic_flag *__a) noexcept

bool	atomic_flag_test_and_set (volatile atomic_flag *__a) noexcept

bool	atomic_flag_test_and_set_explicit (atomic_flag *__a, memory_order __m) noexcept

bool	atomic_flag_test_and_set_explicit (volatile atomic_flag *__a, memory_order __m) noexcept

template<typename _ITp >
void	atomic_init (atomic< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
void	atomic_init (volatile atomic< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
bool	atomic_is_lock_free (const atomic< _ITp > *__a) noexcept

template<typename _ITp >
bool	atomic_is_lock_free (const volatile atomic< _ITp > *__a) noexcept

template<typename _ITp >
_ITp	atomic_load (const atomic< _ITp > *__a) noexcept

template<typename _ITp >
_ITp	atomic_load (const volatile atomic< _ITp > *__a) noexcept

template<typename _ITp >
_ITp	atomic_load_explicit (const atomic< _ITp > *__a, memory_order __m) noexcept

template<typename _ITp >
_ITp	atomic_load_explicit (const volatile atomic< _ITp > *__a, memory_order __m) noexcept

template<typename _ITp >
void	atomic_store (atomic< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
void	atomic_store (volatile atomic< _ITp > *__a, _ITp __i) noexcept

template<typename _ITp >
void	atomic_store_explicit (atomic< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _ITp >
void	atomic_store_explicit (volatile atomic< _ITp > *__a, _ITp __i, memory_order __m) noexcept

template<typename _Container >
back_insert_iterator< _Container >	back_inserter (_Container &__x)

template<class _Container >
auto	begin (_Container &__cont) -> decltype(__cont.begin())

template<class _Container >
auto	begin (const _Container &__cont) -> decltype(__cont.begin())

template<class _Tp >
constexpr const _Tp *	begin (initializer_list< _Tp > __ils) noexcept

template<class _Tp >
_Tp *	begin (valarray< _Tp > &__va)

template<class _Tp >
const _Tp *	begin (const valarray< _Tp > &__va)

template<typename _FIter , typename _Tp >
bool	binary_search (_FIter, _FIter, const _Tp &)

template<typename _FIter , typename _Tp , typename _Compare >
bool	binary_search (_FIter, _FIter, const _Tp &, _Compare)

template<typename _ForwardIterator , typename _Tp >
bool	binary_search (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val)

template<typename _ForwardIterator , typename _Tp , typename _Compare >
bool	binary_search (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val, _Compare __comp)

template<typename _Func , typename... _BoundArgs>
_Bind_helper< __is_socketlike < _Func >::value, _Func, _BoundArgs...>::type	bind (_Func &&__f, _BoundArgs &&...__args)

template<typename _Result , typename _Func , typename... _BoundArgs>
_Bindres_helper< _Result, _Func, _BoundArgs...>::type	bind (_Func &&__f, _BoundArgs &&...__args)

template<typename _Operation , typename _Tp >
binder1st< _Operation >	bind1st (const _Operation &__fn, const _Tp &__x)

template<typename _Operation , typename _Tp >
binder2nd< _Operation >	bind2nd (const _Operation &__fn, const _Tp &__x)

ios_base &	boolalpha (ios_base &__base)

template<typename _Callable , typename... _Args>
void	call_once (once_flag &__once, _Callable &&__f, _Args &&...__args)

constexpr float	ceil (float __x)

constexpr long double	ceil (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	ceil (_Tp __x)

template<typename _Tp >
complex< _Tp >	conj (const complex< _Tp > &)

template<typename _Tp >
__gnu_cxx::__promote< _Tp >::__type	conj (_Tp __x)

template<typename _Tp , typename _Tp1 >
shared_ptr< _Tp >	const_pointer_cast (const shared_ptr< _Tp1 > &__r) noexcept

template<typename _Tp , typename _Tp1 , _Lock_policy _Lp>
__shared_ptr< _Tp, _Lp >	const_pointer_cast (const __shared_ptr< _Tp1, _Lp > &__r) noexcept

this _M_impl	construct (this->_M_impl._M_start._M_cur, std::forward< _Args >(__args)...)

template<typename _IIter , typename _OIter >
_OIter	copy (_IIter, _IIter, _OIter)

template<typename _CharT >
__gnu_cxx::__enable_if < __is_char< _CharT >::__value, ostreambuf_iterator< _CharT > >::__type	copy (istreambuf_iterator< _CharT > __first, istreambuf_iterator< _CharT > __last, ostreambuf_iterator< _CharT > __result)

template<typename _Tp >
_Deque_iterator< _Tp, _Tp &, _Tp * >	copy (_Deque_iterator< _Tp, _Tp &, _Tp * > __first, _Deque_iterator< _Tp, _Tp &, _Tp * > __last, _Deque_iterator< _Tp, _Tp &, _Tp * > __result)

template<typename _II , typename _OI >
_OI	copy (_II __first, _II __last, _OI __result)

template<typename _Tp >
_Deque_iterator< _Tp, _Tp &, _Tp * >	copy (_Deque_iterator< _Tp, const _Tp &, const _Tp * > __first, _Deque_iterator< _Tp, const _Tp &, const _Tp * > __last, _Deque_iterator< _Tp, _Tp &, _Tp * > __result)

template<typename _BIter1 , typename _BIter2 >
_BIter2	copy_backward (_BIter1, _BIter1, _BIter2)

template<typename _Tp >
_Deque_iterator< _Tp, _Tp &, _Tp * >	copy_backward (_Deque_iterator< _Tp, _Tp &, _Tp * > __first, _Deque_iterator< _Tp, _Tp &, _Tp * > __last, _Deque_iterator< _Tp, _Tp &, _Tp * > __result)

template<typename _BI1 , typename _BI2 >
_BI2	copy_backward (_BI1 __first, _BI1 __last, _BI2 __result)

template<typename _Tp >
_Deque_iterator< _Tp, _Tp &, _Tp * >	copy_backward (_Deque_iterator< _Tp, const _Tp &, const _Tp * > __first, _Deque_iterator< _Tp, const _Tp &, const _Tp * > __last, _Deque_iterator< _Tp, _Tp &, _Tp * > __result)

template<typename _Ex >
exception_ptr	copy_exception (_Ex __ex) noexcept 1

template<typename _IIter , typename _OIter , typename _Predicate >
_OIter	copy_if (_IIter, _IIter, _OIter, _Predicate)

template<typename _InputIterator , typename _OutputIterator , typename _Predicate >
_OutputIterator	copy_if (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)

template<typename _IIter , typename _Size , typename _OIter >
_OIter	copy_n (_IIter, _Size, _OIter)

template<typename _InputIterator , typename _Size , typename _OutputIterator >
_OutputIterator	copy_n (_InputIterator __first, _Size __n, _OutputIterator __result)

template<typename _Tp >
complex< _Tp >	cos (const complex< _Tp > &)

constexpr float	cos (float __x)

constexpr long double	cos (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	cos (_Tp __x)

template<class _Dom >
_Expr< _UnClos< _Cos, _Expr, _Dom >, typename _Dom::value_type >	cos (const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _UnClos< _Cos, _ValArray, _Tp >, _Tp >	cos (const valarray< _Tp > &__v)

template<typename _Tp >
complex< _Tp >	cosh (const complex< _Tp > &)

constexpr float	cosh (float __x)

constexpr long double	cosh (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	cosh (_Tp __x)

template<class _Dom >
_Expr< _UnClos< _Cosh, _Expr, _Dom >, typename _Dom::value_type >	cosh (const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _UnClos< _Cosh, _ValArray, _Tp >, _Tp >	cosh (const valarray< _Tp > &__v)

template<typename _IIter , typename _Tp >
iterator_traits< _IIter > ::difference_type	count (_IIter, _IIter, const _Tp &)

size_t	count () const noexcept

template<typename _InputIterator , typename _Tp >
iterator_traits < _InputIterator > ::difference_type	count (_InputIterator __first, _InputIterator __last, const _Tp &__value)

template<typename _IIter , typename _Predicate >
iterator_traits< _IIter > ::difference_type	count_if (_IIter, _IIter, _Predicate)

template<typename _InputIterator , typename _Predicate >
iterator_traits < _InputIterator > ::difference_type	count_if (_InputIterator __first, _InputIterator __last, _Predicate __pred)

exception_ptr	current_exception () noexcept

ios_base &	dec (ios_base &__base)

template<typename... _Args>
void	deque< _Tp, _Alloc >_M_reserve_map_at_back ()

template<typename... _Args>
void	deque< _Tp, _Alloc >_M_reserve_map_at_front ()

template<typename _Tp , typename _Alloc >
deque< _Tp, _Alloc >::iterator	deque< _Tp, _Alloc >if (__position._M_cur==this->_M_impl._M_start._M_cur)

template<typename _InputIterator >
iterator_traits < _InputIterator > ::difference_type	distance (_InputIterator __first, _InputIterator __last)

template<typename _Tp , typename _Tp1 >
shared_ptr< _Tp >	dynamic_pointer_cast (const shared_ptr< _Tp1 > &__r) noexcept

template<typename _Tp , typename _Tp1 , _Lock_policy _Lp>
__shared_ptr< _Tp, _Lp >	dynamic_pointer_cast (const __shared_ptr< _Tp1, _Lp > &__r) noexcept

template<class _Container >
auto	end (_Container &__cont) -> decltype(__cont.end())

template<class _Container >
auto	end (const _Container &__cont) -> decltype(__cont.end())

template<class _Tp >
constexpr const _Tp *	end (initializer_list< _Tp > __ils) noexcept

template<class _Tp >
_Tp *	end (valarray< _Tp > &__va)

template<class _Tp >
const _Tp *	end (const valarray< _Tp > &__va)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	endl (basic_ostream< _CharT, _Traits > &__os)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	ends (basic_ostream< _CharT, _Traits > &__os)

template<typename _IIter1 , typename _IIter2 >
bool	equal (_IIter1, _IIter1, _IIter2)

template<typename _IIter1 , typename _IIter2 , typename _BinaryPredicate >
bool	equal (_IIter1 __first1, _IIter1 __last1, _IIter2 __first2, _BinaryPredicate __binary_pred)

template<typename _II1 , typename _II2 >
bool	equal (_II1 __first1, _II1 __last1, _II2 __first2)

template<typename _FIter , typename _Tp >
pair< _FIter, _FIter >	equal_range (_FIter, _FIter, const _Tp &)

template<typename _FIter , typename _Tp , typename _Compare >
pair< _FIter, _FIter >	equal_range (_FIter, _FIter, const _Tp &, _Compare)

template<typename _ForwardIterator , typename _Tp >
pair< _ForwardIterator, _ForwardIterator >	equal_range (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val)

template<typename _ForwardIterator , typename _Tp , typename _Compare >
pair< _ForwardIterator, _ForwardIterator >	equal_range (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val, _Compare __comp)

void	exit (int) throw ()

template<typename _Tp >
complex< _Tp >	exp (const complex< _Tp > &)

constexpr float	exp (float __x)

constexpr long double	exp (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	exp (_Tp __x)

template<class _Dom >
_Expr< _UnClos< _Exp, _Expr, _Dom >, typename _Dom::value_type >	exp (const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _UnClos< _Exp, _ValArray, _Tp >, _Tp >	exp (const valarray< _Tp > &__v)

constexpr float	fabs (float __x)

constexpr long double	fabs (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	fabs (_Tp __x)

template<typename _Tp >
_Tp	fabs (const std::complex< _Tp > &__z)

template<typename _FIter , typename _Tp >
void	fill (_FIter, _FIter, const _Tp &)

void	fill (_Bit_iterator __first, _Bit_iterator __last, const bool &__x)

template<typename _ForwardIterator , typename _Tp >
void	fill (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__value)

template<typename _Tp >
void	fill (const _Deque_iterator< _Tp, _Tp &, _Tp * > &__first, const _Deque_iterator< _Tp, _Tp &, _Tp * > &__last, const _Tp &__value)

template<typename _OIter , typename _Size , typename _Tp >
_OIter	fill_n (_OIter, _Size, const _Tp &)

template<typename _OI , typename _Size , typename _Tp >
_OI	fill_n (_OI __first, _Size __n, const _Tp &__value)

template<typename _CharT >
__gnu_cxx::__enable_if < __is_char< _CharT >::__value, istreambuf_iterator< _CharT > >::__type	find (istreambuf_iterator< _CharT > __first, istreambuf_iterator< _CharT > __last, const _CharT &__val)

template<typename _IIter , typename _Tp >
_IIter	find (_IIter, _IIter, const _Tp &)

template<typename _InputIterator , typename _Tp >
_InputIterator	find (_InputIterator __first, _InputIterator __last, const _Tp &__val)

template<typename _FIter1 , typename _FIter2 >
_FIter1	find_end (_FIter1, _FIter1, _FIter2, _FIter2)

template<typename _FIter1 , typename _FIter2 , typename _BinaryPredicate >
_FIter1	find_end (_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate)

template<typename _ForwardIterator1 , typename _ForwardIterator2 >
_ForwardIterator1	find_end (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2)

template<typename _ForwardIterator1 , typename _ForwardIterator2 , typename _BinaryPredicate >
_ForwardIterator1	find_end (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __comp)

template<typename _FIter1 , typename _FIter2 >
_FIter1	find_first_of (_FIter1, _FIter1, _FIter2, _FIter2)

template<typename _FIter1 , typename _FIter2 , typename _BinaryPredicate >
_FIter1	find_first_of (_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate)

template<typename _InputIterator , typename _ForwardIterator >
_InputIterator	find_first_of (_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2)

template<typename _InputIterator , typename _ForwardIterator , typename _BinaryPredicate >
_InputIterator	find_first_of (_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2, _BinaryPredicate __comp)

template<typename _IIter , typename _Predicate >
_IIter	find_if (_IIter, _IIter, _Predicate)

template<typename _InputIterator , typename _Predicate >
_InputIterator	find_if (_InputIterator __first, _InputIterator __last, _Predicate __pred)

template<typename _IIter , typename _Predicate >
_IIter	find_if_not (_IIter, _IIter, _Predicate)

template<typename _InputIterator , typename _Predicate >
_InputIterator	find_if_not (_InputIterator __first, _InputIterator __last, _Predicate __pred)

ios_base &	fixed (ios_base &__base)

bitset< _Nb > &	flip () noexcept

bitset< _Nb > &	flip (size_t __position)

constexpr float	floor (float __x)

constexpr long double	floor (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	floor (_Tp __x)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	flush (basic_ostream< _CharT, _Traits > &__os)

constexpr float	fmod (float __x, float __y)

constexpr long double	fmod (long double __x, long double __y)

template<typename _Tp , typename _Up >
constexpr __gnu_cxx::__promote_2< _Tp, _Up >::__type	fmod (_Tp __x, _Up __y)

template<typename _IIter , typename _Funct >
_Funct	for_each (_IIter, _IIter, _Funct)

template<typename _InputIterator , typename _Function >
_Function	for_each (_InputIterator __first, _InputIterator __last, _Function __f)

template<typename _Tp >
constexpr _Tp &&	forward (typename std::remove_reference< _Tp >::type &__t) noexcept

template<typename _Tp >
constexpr _Tp &&	forward (typename std::remove_reference< _Tp >::type &&__t) noexcept

template<typename... _Elements>
tuple< _Elements &&...>	forward_as_tuple (_Elements &&...__args) noexcept

float	frexp (float __x, int *__exp)

long double	frexp (long double __x, int *__exp)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	frexp (_Tp __x, int *__exp)

template<typename _Container >
front_insert_iterator< _Container >	front_inserter (_Container &__x)

const error_category &	future_category () noexcept

template<typename _FIter , typename _Generator >
void	generate (_FIter, _FIter, _Generator)

template<typename _ForwardIterator , typename _Generator >
void	generate (_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)

template<typename _RealType , size_t __bits, typename _UniformRandomNumberGenerator >
_RealType	generate_canonical (_UniformRandomNumberGenerator &__g)

template<typename _OIter , typename _Size , typename _Generator >
_OIter	generate_n (_OIter, _Size, _Generator)

template<typename _OutputIterator , typename _Size , typename _Generator >
_OutputIterator	generate_n (_OutputIterator __first, _Size __n, _Generator __gen)

const error_category &	generic_category () noexcept

template<std::size_t _Int, class _Tp1 , class _Tp2 >
constexpr tuple_element< _Int, std::pair< _Tp1, _Tp2 > >::type &	get (std::pair< _Tp1, _Tp2 > &__in) noexcept

template<std::size_t _Int, class _Tp1 , class _Tp2 >
constexpr tuple_element< _Int, std::pair< _Tp1, _Tp2 > >::type &&	get (std::pair< _Tp1, _Tp2 > &&__in) noexcept

template<std::size_t _Int, class _Tp1 , class _Tp2 >
constexpr const tuple_element < _Int, std::pair< _Tp1, _Tp2 > >::type &	get (const std::pair< _Tp1, _Tp2 > &__in) noexcept

template<std::size_t _Int, typename _Tp , std::size_t _Nm>
constexpr _Tp &	get (array< _Tp, _Nm > &__arr) noexcept

template<std::size_t _Int, typename _Tp , std::size_t _Nm>
constexpr _Tp &&	get (array< _Tp, _Nm > &&__arr) noexcept

template<std::size_t _Int, typename _Tp , std::size_t _Nm>
constexpr const _Tp &	get (const array< _Tp, _Nm > &__arr) noexcept

template<std::size_t __i, typename... _Elements>
constexpr __add_ref< typename tuple_element< __i, tuple < _Elements...> >::type > ::type	get (tuple< _Elements...> &__t) noexcept

template<std::size_t __i, typename... _Elements>
constexpr __add_c_ref < typename tuple_element< __i, tuple< _Elements...> >::type > ::type	get (const tuple< _Elements...> &__t) noexcept

template<std::size_t __i, typename... _Elements>
constexpr __add_r_ref < typename tuple_element< __i, tuple< _Elements...> >::type > ::type	get (tuple< _Elements...> &&__t) noexcept

template<typename _Del , typename _Tp , _Lock_policy _Lp>
_Del *	get_deleter (const __shared_ptr< _Tp, _Lp > &__p) noexcept

template<typename _MoneyT >
_Get_money< _MoneyT >	get_money (_MoneyT &__mon, bool __intl=false)

new_handler	get_new_handler () noexcept

template<typename _Tp >
pair< _Tp *, ptrdiff_t >	get_temporary_buffer (ptrdiff_t __len) noexcept

terminate_handler	get_terminate () noexcept

unexpected_handler	get_unexpected () noexcept

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base>
basic_istream< _CharT, _Traits > &	getline (basic_istream< _CharT, _Traits > &__is, __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base > &__str, _CharT __delim)

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base>
basic_istream< _CharT, _Traits > &	getline (basic_istream< _CharT, _Traits > &__is, __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base > &__str)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_istream< _CharT, _Traits > &	getline (basic_istream< _CharT, _Traits > &__is, basic_string< _CharT, _Traits, _Alloc > &__str, _CharT __delim)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_istream< _CharT, _Traits > &	getline (basic_istream< _CharT, _Traits > &__is, basic_string< _CharT, _Traits, _Alloc > &__str)

template<>
basic_istream< char > &	getline (basic_istream< char > &__in, basic_string< char > &__str, char __delim)

template<>
basic_istream< wchar_t > &	getline (basic_istream< wchar_t > &__in, basic_string< wchar_t > &__str, wchar_t __delim)

template<typename _Facet >
bool	has_facet (const locale &__loc) throw ()

ios_base &	hex (ios_base &__base)

	if (this->_M_impl._M_finish!=this->_M_impl._M_end_of_storage &&__position==end())

else	if (__position._M_cur==this->_M_impl._M_finish._M_cur)

else	if (__t._M_root()==0)

template<typename _Tp >
constexpr _Tp	imag (const complex< _Tp > &__z)

template<typename _Tp >
__gnu_cxx::__promote< _Tp >::__type	imag (_Tp)

template<typename _IIter1 , typename _IIter2 >
bool	includes (_IIter1, _IIter1, _IIter2, _IIter2)

template<typename _IIter1 , typename _IIter2 , typename _Compare >
bool	includes (_IIter1, _IIter1, _IIter2, _IIter2, _Compare)

template<typename _InputIterator1 , typename _InputIterator2 >
bool	includes (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)

template<typename _InputIterator1 , typename _InputIterator2 , typename _Compare >
bool	includes (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)

template<typename _InputIterator1 , typename _InputIterator2 , typename _Tp >
_Tp	inner_product (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init)

template<typename _InputIterator1 , typename _InputIterator2 , typename _Tp , typename _BinaryOperation1 , typename _BinaryOperation2 >
_Tp	inner_product (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2)

template<typename _BIter >
void	inplace_merge (_BIter, _BIter, _BIter)

template<typename _BIter , typename _Compare >
void	inplace_merge (_BIter, _BIter, _BIter, _Compare)

template<typename _BidirectionalIterator >
void	inplace_merge (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last)

template<typename _BidirectionalIterator , typename _Compare >
void	inplace_merge (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp)

template<typename _Container , typename _Iterator >
insert_iterator< _Container >	inserter (_Container &__x, _Iterator __i)

ios_base &	internal (ios_base &__base)

template<typename _ForwardIterator , typename _Tp >
void	iota (_ForwardIterator __first, _ForwardIterator __last, _Tp __value)

template<typename _RAIter >
bool	is_heap (_RAIter, _RAIter)

template<typename _RAIter , typename _Compare >
bool	is_heap (_RAIter, _RAIter, _Compare)

template<typename _RandomAccessIterator >
bool	is_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)

template<typename _RandomAccessIterator , typename _Compare >
bool	is_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _RAIter >
_RAIter	is_heap_until (_RAIter, _RAIter)

template<typename _RAIter , typename _Compare >
_RAIter	is_heap_until (_RAIter, _RAIter, _Compare)

template<typename _RandomAccessIterator >
_RandomAccessIterator	is_heap_until (_RandomAccessIterator __first, _RandomAccessIterator __last)

template<typename _RandomAccessIterator , typename _Compare >
_RandomAccessIterator	is_heap_until (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _IIter , typename _Predicate >
bool	is_partitioned (_IIter, _IIter, _Predicate)

template<typename _InputIterator , typename _Predicate >
bool	is_partitioned (_InputIterator __first, _InputIterator __last, _Predicate __pred)

template<typename _FIter1 , typename _FIter2 >
bool	is_permutation (_FIter1, _FIter1, _FIter2)

template<typename _FIter1 , typename _FIter2 , typename _BinaryPredicate >
bool	is_permutation (_FIter1, _FIter1, _FIter2, _BinaryPredicate)

template<typename _ForwardIterator1 , typename _ForwardIterator2 >
bool	is_permutation (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)

template<typename _ForwardIterator1 , typename _ForwardIterator2 , typename _BinaryPredicate >
bool	is_permutation (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __pred)

template<typename _FIter >
bool	is_sorted (_FIter, _FIter)

template<typename _FIter , typename _Compare >
bool	is_sorted (_FIter, _FIter, _Compare)

template<typename _ForwardIterator >
bool	is_sorted (_ForwardIterator __first, _ForwardIterator __last)

template<typename _ForwardIterator , typename _Compare >
bool	is_sorted (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

template<typename _FIter >
_FIter	is_sorted_until (_FIter, _FIter)

template<typename _FIter , typename _Compare >
_FIter	is_sorted_until (_FIter, _FIter, _Compare)

template<typename _ForwardIterator >
_ForwardIterator	is_sorted_until (_ForwardIterator __first, _ForwardIterator __last)

template<typename _ForwardIterator , typename _Compare >
_ForwardIterator	is_sorted_until (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

template<typename _CharT >
bool	isalnum (_CharT __c, const locale &__loc)

template<typename _CharT >
bool	isalpha (_CharT __c, const locale &__loc)

template<typename _CharT >
bool	iscntrl (_CharT __c, const locale &__loc)

template<typename _CharT >
bool	isdigit (_CharT __c, const locale &__loc)

template<typename _CharT >
bool	isgraph (_CharT __c, const locale &__loc)

template<typename _CharT >
bool	islower (_CharT __c, const locale &__loc)

template<typename _CharT >
bool	isprint (_CharT __c, const locale &__loc)

template<typename _CharT >
bool	ispunct (_CharT __c, const locale &__loc)

template<typename _CharT >
bool	isspace (_CharT __c, const locale &__loc)

template<typename _CharT >
bool	isupper (_CharT __c, const locale &__loc)

template<typename _CharT >
bool	isxdigit (_CharT __c, const locale &__loc)

template<typename _ForwardIterator1 , typename _ForwardIterator2 >
void	iter_swap (_ForwardIterator1 __a, _ForwardIterator2 __b)

template<typename _FIter1 , typename _FIter2 >
void	iter_swap (_FIter1, _FIter2)

return	iterator (__tmp)

return	iterator (this->_M_impl._M_start+__n)

return	iterator (__z)

return	iterator (static_cast< _Link_type >(__res.first))

template<typename _Tp >
_Tp	kill_dependency (_Tp __y) noexcept

constexpr float	ldexp (float __x, int __exp)

constexpr long double	ldexp (long double __x, int __exp)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	ldexp (_Tp __x, int __exp)

ios_base &	left (ios_base &__base)

template<typename _IIter1 , typename _IIter2 >
bool	lexicographical_compare (_IIter1, _IIter1, _IIter2, _IIter2)

template<typename _IIter1 , typename _IIter2 , typename _Compare >
bool	lexicographical_compare (_IIter1, _IIter1, _IIter2, _IIter2, _Compare)

template<typename _II1 , typename _II2 >
bool	lexicographical_compare (_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)

template<typename _II1 , typename _II2 , typename _Compare >
bool	lexicographical_compare (_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _Compare __comp)

template<typename _Tp , typename _Alloc >
void	list< _Tp, _Alloc >if (this!=&__x)

template<typename _StrictWeakOrdering >
void	list< _Tp, _Alloc >if (this!=&__x)

template<typename _L1 , typename _L2 , typename... _L3>
void	lock (_L1 &__l1, _L2 &__l2, _L3 &...__l3)

template<typename _Tp >
complex< _Tp >	log (const complex< _Tp > &)

constexpr float	log (float __x)

constexpr long double	log (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	log (_Tp __x)

template<class _Dom >
_Expr< _UnClos< _Log, _Expr, _Dom >, typename _Dom::value_type >	log (const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _UnClos< _Log, _ValArray, _Tp >, _Tp >	log (const valarray< _Tp > &__v)

template<typename _Tp >
complex< _Tp >	log10 (const complex< _Tp > &)

constexpr float	log10 (float __x)

constexpr long double	log10 (long double __x)

template<typename _Tp >
constexpr __gnu_cxx::__enable_if < __is_integer< _Tp >::__value, double >::__type	log10 (_Tp __x)

template<class _Dom >
_Expr< _UnClos< _Log10, _Expr, _Dom >, typename _Dom::value_type >	log10 (const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _UnClos< _Log10, _ValArray, _Tp >, _Tp >	log10 (const valarray< _Tp > &__v)

template<typename _FIter , typename _Tp >
_FIter	lower_bound (_FIter, _FIter, const _Tp &)

template<typename _FIter , typename _Tp , typename _Compare >
_FIter	lower_bound (_FIter, _FIter, const _Tp &, _Compare)

template<typename _ForwardIterator , typename _Tp >
_ForwardIterator	lower_bound (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val)

template<typename _ForwardIterator , typename _Tp , typename _Compare >
_ForwardIterator	lower_bound (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val, _Compare __comp)

error_code	make_error_code (future_errc __errc) noexcept

error_code	make_error_code (errc __e) noexcept

error_condition	make_error_condition (future_errc __errc) noexcept

error_condition	make_error_condition (errc __e) noexcept

template<typename _Ex >
exception_ptr	make_exception_ptr (_Ex __ex) noexcept

template<typename _RAIter >
void	make_heap (_RAIter, _RAIter)

template<typename _RandomAccessIterator >
void	make_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)

template<typename _RAIter , typename _Compare >
void	make_heap (_RAIter, _RAIter, _Compare)

template<typename _RandomAccessIterator , typename _Compare >
void	make_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

template<typename _Iterator >
move_iterator< _Iterator >	make_move_iterator (_Iterator __i)

template<class _T1 , class _T2 >
constexpr pair< typename __decay_and_strip< _T1 > ::__type, typename __decay_and_strip< _T2 > ::__type >	make_pair (_T1 &&__x, _T2 &&__y)

template<typename _Tp , typename... _Args>
shared_ptr< _Tp >	make_shared (_Args &&...__args)

template<typename... _Elements>
constexpr tuple< typename __decay_and_strip< _Elements > ::__type...>	make_tuple (_Elements &&...__args)

template<typename _Tp >
const _Tp &	max (const _Tp &__a, const _Tp &__b)

template<typename _Tp , typename _Compare >
const _Tp &	max (const _Tp &__a, const _Tp &__b, _Compare __comp)

template<typename _Tp >
_Tp	max (initializer_list< _Tp >)

template<typename _Tp , typename _Compare >
_Tp	max (initializer_list< _Tp >, _Compare)

template<typename _FIter >
_FIter	max_element (_FIter, _FIter)

template<typename _FIter , typename _Compare >
_FIter	max_element (_FIter, _FIter, _Compare)

template<typename _ForwardIterator >
_ForwardIterator	max_element (_ForwardIterator __first, _ForwardIterator __last)

template<typename _ForwardIterator , typename _Compare >
_ForwardIterator	max_element (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

template<typename _Tp , typename _Class >
_Mem_fn< _Tp _Class::* >	mem_fn (_Tp _Class::*__pm) noexcept

template<typename _Ret , typename _Tp >
mem_fun_t< _Ret, _Tp >	mem_fun (_Ret(_Tp::*__f)())

template<typename _Ret , typename _Tp >
const_mem_fun_t< _Ret, _Tp >	mem_fun (_Ret(_Tp::*__f)() const)

template<typename _Ret , typename _Tp , typename _Arg >
mem_fun1_t< _Ret, _Tp, _Arg >	mem_fun (_Ret(_Tp::*__f)(_Arg))

template<typename _Ret , typename _Tp , typename _Arg >
const_mem_fun1_t< _Ret, _Tp, _Arg >	mem_fun (_Ret(_Tp::*__f)(_Arg) const)

template<typename _Ret , typename _Tp >
mem_fun_ref_t< _Ret, _Tp >	mem_fun_ref (_Ret(_Tp::*__f)())

template<typename _Ret , typename _Tp >
const_mem_fun_ref_t< _Ret, _Tp >	mem_fun_ref (_Ret(_Tp::*__f)() const)

template<typename _Ret , typename _Tp , typename _Arg >
mem_fun1_ref_t< _Ret, _Tp, _Arg >	mem_fun_ref (_Ret(_Tp::*__f)(_Arg))

template<typename _Ret , typename _Tp , typename _Arg >
const_mem_fun1_ref_t< _Ret, _Tp, _Arg >	mem_fun_ref (_Ret(_Tp::*__f)(_Arg) const)

void *	memchr (void *__s, int __c, size_t __n)

template<typename _IIter1 , typename _IIter2 , typename _OIter >
_OIter	merge (_IIter1, _IIter1, _IIter2, _IIter2, _OIter)

template<typename _IIter1 , typename _IIter2 , typename _OIter , typename _Compare >
_OIter	merge (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare)

template<typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator >
_OutputIterator	merge (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)

template<typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator , typename _Compare >
_OutputIterator	merge (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

template<typename _Tp >
const _Tp &	min (const _Tp &__a, const _Tp &__b)

template<typename _Tp , typename _Compare >
const _Tp &	min (const _Tp &__a, const _Tp &__b, _Compare __comp)

template<typename _Tp >
_Tp	min (initializer_list< _Tp >)

template<typename _Tp , typename _Compare >
_Tp	min (initializer_list< _Tp >, _Compare)

template<typename _FIter >
_FIter	min_element (_FIter, _FIter)

template<typename _FIter , typename _Compare >
_FIter	min_element (_FIter, _FIter, _Compare)

template<typename _ForwardIterator >
_ForwardIterator	min_element (_ForwardIterator __first, _ForwardIterator __last)

template<typename _ForwardIterator , typename _Compare >
_ForwardIterator	min_element (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

template<typename _Tp >
pair< const _Tp &, const _Tp & >	minmax (const _Tp &__a, const _Tp &__b)

template<typename _Tp , typename _Compare >
pair< const _Tp &, const _Tp & >	minmax (const _Tp &__a, const _Tp &__b, _Compare __comp)

template<typename _Tp >
pair< _Tp, _Tp >	minmax (initializer_list< _Tp >)

template<typename _Tp , typename _Compare >
pair< _Tp, _Tp >	minmax (initializer_list< _Tp >, _Compare)

template<typename _FIter >
pair< _FIter, _FIter >	minmax_element (_FIter, _FIter)

template<typename _FIter , typename _Compare >
pair< _FIter, _FIter >	minmax_element (_FIter, _FIter, _Compare)

template<typename _ForwardIterator >
pair< _ForwardIterator, _ForwardIterator >	minmax_element (_ForwardIterator __first, _ForwardIterator __last)

template<typename _ForwardIterator , typename _Compare >
pair< _ForwardIterator, _ForwardIterator >	minmax_element (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

template<typename _IIter1 , typename _IIter2 >
pair< _IIter1, _IIter2 >	mismatch (_IIter1, _IIter1, _IIter2)

template<typename _IIter1 , typename _IIter2 , typename _BinaryPredicate >
pair< _IIter1, _IIter2 >	mismatch (_IIter1, _IIter1, _IIter2, _BinaryPredicate)

template<typename _InputIterator1 , typename _InputIterator2 >
pair< _InputIterator1, _InputIterator2 >	mismatch (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)

template<typename _InputIterator1 , typename _InputIterator2 , typename _BinaryPredicate >
pair< _InputIterator1, _InputIterator2 >	mismatch (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __binary_pred)

float	modf (float __x, float *__iptr)

long double	modf (long double __x, long double *__iptr)

template<typename _Tp >
constexpr std::remove_reference< _Tp > ::type &&	move (_Tp &&__t) noexcept

template<typename _Tp >
_Deque_iterator< _Tp, _Tp &, _Tp * >	move (_Deque_iterator< _Tp, _Tp &, _Tp * > __first, _Deque_iterator< _Tp, _Tp &, _Tp * > __last, _Deque_iterator< _Tp, _Tp &, _Tp * > __result)

template<typename _II , typename _OI >
_OI	move (_II __first, _II __last, _OI __result)

template<typename _Tp >
_Deque_iterator< _Tp, _Tp &, _Tp * >	move (_Deque_iterator< _Tp, const _Tp &, const _Tp * > __first, _Deque_iterator< _Tp, const _Tp &, const _Tp * > __last, _Deque_iterator< _Tp, _Tp &, _Tp * > __result)

template<typename _Tp >
_Deque_iterator< _Tp, _Tp &, _Tp * >	move_backward (_Deque_iterator< _Tp, _Tp &, _Tp * > __first, _Deque_iterator< _Tp, _Tp &, _Tp * > __last, _Deque_iterator< _Tp, _Tp &, _Tp * > __result)

template<typename _BI1 , typename _BI2 >
_BI2	move_backward (_BI1 __first, _BI1 __last, _BI2 __result)

template<typename _Tp >
_Deque_iterator< _Tp, _Tp &, _Tp * >	move_backward (_Deque_iterator< _Tp, const _Tp &, const _Tp * > __first, _Deque_iterator< _Tp, const _Tp &, const _Tp * > __last, _Deque_iterator< _Tp, _Tp &, _Tp * > __result)

template<typename _Tp >
constexpr conditional < __move_if_noexcept_cond< _Tp > ::value, const _Tp &, _Tp && > ::type	move_if_noexcept (_Tp &__x) noexcept

template<typename _ForwardIterator >
_ForwardIterator	next (_ForwardIterator __x, typename iterator_traits< _ForwardIterator >::difference_type __n=1)

template<typename _BIter >
bool	next_permutation (_BIter, _BIter)

template<typename _BIter , typename _Compare >
bool	next_permutation (_BIter, _BIter, _Compare)

template<typename _BidirectionalIterator >
bool	next_permutation (_BidirectionalIterator __first, _BidirectionalIterator __last)

template<typename _BidirectionalIterator , typename _Compare >
bool	next_permutation (_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)

ios_base &	noboolalpha (ios_base &__base)

template<class _T1 , class _T2 >
void	noexcept (noexcept(__x.swap(__y)))

template<typename _Tp , std::size_t _Nm>
void	noexcept (noexcept(__one.swap(__two)))

template<typename _Tp >
void	noexcept (__and_< is_nothrow_move_constructible< _Tp >, is_nothrow_move_assignable< _Tp >>::value)

template<typename... _Elements>
void	noexcept (noexcept(__x.swap(__y)))

bool	none () const noexcept

template<typename _IIter , typename _Predicate >
bool	none_of (_IIter, _IIter, _Predicate)

template<typename _InputIterator , typename _Predicate >
bool	none_of (_InputIterator __first, _InputIterator __last, _Predicate __pred)

template<typename _Tp >
_Tp	norm (const complex< _Tp > &)

template<typename _Tp >
__gnu_cxx::__promote< _Tp >::__type	norm (_Tp __x)

ios_base &	noshowbase (ios_base &__base)

ios_base &	noshowpoint (ios_base &__base)

ios_base &	noshowpos (ios_base &__base)

ios_base &	noskipws (ios_base &__base)

template<typename _Predicate >
unary_negate< _Predicate >	not1 (const _Predicate &__pred)

template<typename _Predicate >
binary_negate< _Predicate >	not2 (const _Predicate &__pred)

ios_base &	nounitbuf (ios_base &__base)

ios_base &	nouppercase (ios_base &__base)

template<typename _RAIter >
void	nth_element (_RAIter, _RAIter, _RAIter)

template<typename _RAIter , typename _Compare >
void	nth_element (_RAIter, _RAIter, _RAIter, _Compare)

template<typename _RandomAccessIterator >
void	nth_element (_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last)

template<typename _RandomAccessIterator , typename _Compare >
void	nth_element (_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)

ios_base &	oct (ios_base &__base)

template<class _Tp , class _CharT , class _Traits , class _Dist >
bool	operator!= (const istream_iterator< _Tp, _CharT, _Traits, _Dist > &__x, const istream_iterator< _Tp, _CharT, _Traits, _Dist > &__y)

template<typename _T1 , typename _T2 >
bool	operator!= (const allocator< _T1 > &, const allocator< _T2 > &)

template<typename _Tp >
bool	operator!= (const allocator< _Tp > &, const allocator< _Tp > &)

bool	operator!= (thread::id __x, thread::id __y) noexcept

template<typename _CharT , typename _Traits >
bool	operator!= (const istreambuf_iterator< _CharT, _Traits > &__a, const istreambuf_iterator< _CharT, _Traits > &__b)

template<typename _StateT >
bool	operator!= (const fpos< _StateT > &__lhs, const fpos< _StateT > &__rhs)

template<class _T1 , class _T2 >
constexpr bool	operator!= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)

template<typename _Tp , std::size_t _Nm>
bool	operator!= (const array< _Tp, _Nm > &__one, const array< _Tp, _Nm > &__two)

template<typename _Tp , typename _Ref , typename _Ptr >
bool	operator!= (const _Deque_iterator< _Tp, _Ref, _Ptr > &__x, const _Deque_iterator< _Tp, _Ref, _Ptr > &__y) noexcept

template<typename _Tp >
bool	operator!= (const _Fwd_list_iterator< _Tp > &__x, const _Fwd_list_const_iterator< _Tp > &__y) noexcept

template<typename _Tp , typename _Seq >
bool	operator!= (const stack< _Tp, _Seq > &__x, const stack< _Tp, _Seq > &__y)

template<typename _Tp , typename _RefL , typename _PtrL , typename _RefR , typename _PtrR >
bool	operator!= (const _Deque_iterator< _Tp, _RefL, _PtrL > &__x, const _Deque_iterator< _Tp, _RefR, _PtrR > &__y) noexcept

bool	operator!= (const error_code &__lhs, const error_code &__rhs) noexcept

template<typename _Val >
bool	operator!= (const _List_iterator< _Val > &__x, const _List_const_iterator< _Val > &__y) noexcept

template<typename _Tp , typename _Seq >
bool	operator!= (const queue< _Tp, _Seq > &__x, const queue< _Tp, _Seq > &__y)

bool	operator!= (const error_code &__lhs, const error_condition &__rhs) noexcept

bool	operator!= (const error_condition &__lhs, const error_code &__rhs) noexcept

bool	operator!= (const error_condition &__lhs, const error_condition &__rhs) noexcept

template<typename _Iterator >
bool	operator!= (const reverse_iterator< _Iterator > &__x, const reverse_iterator< _Iterator > &__y)

template<typename _Val >
bool	operator!= (const _Rb_tree_iterator< _Val > &__x, const _Rb_tree_const_iterator< _Val > &__y) noexcept

template<typename _Tp1 , typename _Tp2 >
bool	operator!= (const shared_ptr< _Tp1 > &__a, const shared_ptr< _Tp2 > &__b) noexcept

template<typename _Tp >
bool	operator!= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept

template<typename _IteratorL , typename _IteratorR >
bool	operator!= (const reverse_iterator< _IteratorL > &__x, const reverse_iterator< _IteratorR > &__y)

template<typename _Tp >
bool	operator!= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept

template<typename _UIntType , _UIntType __a, _UIntType __c, _UIntType __m>
bool	operator!= (const std::linear_congruential_engine< _UIntType, __a, __c, __m > &__lhs, const std::linear_congruential_engine< _UIntType, __a, __c, __m > &__rhs)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos < __not_equal_to, _Expr, _Expr, _Dom1, _Dom2 >, typename __fun < __not_equal_to, typename _Dom1::value_type > ::result_type >	operator!= (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos < __not_equal_to, _Expr, _Constant, _Dom, typename _Dom::value_type >, typename __fun< __not_equal_to, typename _Dom::value_type > ::result_type >	operator!= (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos < __not_equal_to, _Expr, _ValArray, _Dom, typename _Dom::value_type >, typename __fun< __not_equal_to, typename _Dom::value_type > ::result_type >	operator!= (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos < __not_equal_to, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun < __not_equal_to, typename _Dom::value_type > ::result_type >	operator!= (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<class _Dom >
_Expr< _BinClos < __not_equal_to, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun < __not_equal_to, typename _Dom::value_type > ::result_type >	operator!= (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<typename _OutA1 , typename _OutA2 , typename... _InA>
bool	operator!= (const scoped_allocator_adaptor< _OutA1, _InA...> &__a, const scoped_allocator_adaptor< _OutA2, _InA...> &__b) noexcept

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool	operator!= (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _UIntType , size_t __w, size_t __n, size_t __m, size_t __r, _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
bool	operator!= (const std::mersenne_twister_engine< _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f > &__lhs, const std::mersenne_twister_engine< _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f > &__rhs)

template<typename _Tp , typename _Dp >
bool	operator!= (const unique_ptr< _Tp, _Dp > &__x, nullptr_t) noexcept

template<typename _Tp , typename _Dp >
bool	operator!= (nullptr_t, const unique_ptr< _Tp, _Dp > &__x) noexcept

template<typename _Key , typename _Compare , typename _Alloc >
bool	operator!= (const multiset< _Key, _Compare, _Alloc > &__x, const multiset< _Key, _Compare, _Alloc > &__y)

template<typename _Key , typename _Compare , typename _Alloc >
bool	operator!= (const set< _Key, _Compare, _Alloc > &__x, const set< _Key, _Compare, _Alloc > &__y)

template<typename _UIntType , size_t __w, size_t __s, size_t __r>
bool	operator!= (const std::subtract_with_carry_engine< _UIntType, __w, __s, __r > &__lhs, const std::subtract_with_carry_engine< _UIntType, __w, __s, __r > &__rhs)

template<typename... _TElements, typename... _UElements>
constexpr bool	operator!= (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)

template<typename _BiIter >
bool	operator!= (const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)

template<typename _Key , typename _Tp , typename _Compare , typename _Alloc >
bool	operator!= (const multimap< _Key, _Tp, _Compare, _Alloc > &__x, const multimap< _Key, _Tp, _Compare, _Alloc > &__y)

template<typename _Key , typename _Val , typename _KeyOfValue , typename _Compare , typename _Alloc >
bool	operator!= (const _Rb_tree< _Key, _Val, _KeyOfValue, _Compare, _Alloc > &__x, const _Rb_tree< _Key, _Val, _KeyOfValue, _Compare, _Alloc > &__y)

template<typename _Bi_iter , typename _Ch_traits , typename _Ch_alloc >
bool	operator!= (const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)

template<typename _Key , typename _Tp , typename _Compare , typename _Alloc >
bool	operator!= (const map< _Key, _Tp, _Compare, _Alloc > &__x, const map< _Key, _Tp, _Compare, _Alloc > &__y)

template<typename _RandomNumberEngine , size_t __p, size_t __r>
bool	operator!= (const std::discard_block_engine< _RandomNumberEngine, __p, __r > &__lhs, const std::discard_block_engine< _RandomNumberEngine, __p, __r > &__rhs)

template<typename _Bi_iter , typename _Ch_traits , typename _Ch_alloc >
bool	operator!= (const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)

template<typename _IteratorL , typename _IteratorR >
bool	operator!= (const move_iterator< _IteratorL > &__x, const move_iterator< _IteratorR > &__y)

template<typename _Iterator >
bool	operator!= (const move_iterator< _Iterator > &__x, const move_iterator< _Iterator > &__y)

template<typename _Tp1 , typename _Tp2 , _Lock_policy _Lp>
bool	operator!= (const __shared_ptr< _Tp1, _Lp > &__a, const __shared_ptr< _Tp2, _Lp > &__b) noexcept

template<typename _Tp , _Lock_policy _Lp>
bool	operator!= (const __shared_ptr< _Tp, _Lp > &__a, nullptr_t) noexcept

template<typename _Tp , _Lock_policy _Lp>
bool	operator!= (nullptr_t, const __shared_ptr< _Tp, _Lp > &__a) noexcept

template<typename _Bi_iter >
bool	operator!= (typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)

template<typename _Tp >
_Expr< _BinClos < __not_equal_to, _ValArray, _ValArray, _Tp, _Tp > , typename __fun < __not_equal_to, _Tp > ::result_type >	operator!= (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<typename _Tp >
_Expr< _BinClos < __not_equal_to, _ValArray, _Constant, _Tp, _Tp > , typename __fun < __not_equal_to, _Tp > ::result_type >	operator!= (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos < __not_equal_to, _Constant, _ValArray, _Tp, _Tp > , typename __fun < __not_equal_to, _Tp > ::result_type >	operator!= (const _Tp &__t, const valarray< _Tp > &__v)

template<typename _Bi_iter >
bool	operator!= (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)

template<typename _RandomNumberEngine , size_t __w, typename _UIntType >
bool	operator!= (const std::independent_bits_engine< _RandomNumberEngine, __w, _UIntType > &__lhs, const std::independent_bits_engine< _RandomNumberEngine, __w, _UIntType > &__rhs)

template<typename _Bi_iter >
bool	operator!= (typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)

template<class _Value , class _Hash , class _Pred , class _Alloc >
bool	operator!= (const unordered_set< _Value, _Hash, _Pred, _Alloc > &__x, const unordered_set< _Value, _Hash, _Pred, _Alloc > &__y)

template<class _Value , class _Hash , class _Pred , class _Alloc >
bool	operator!= (const unordered_multiset< _Value, _Hash, _Pred, _Alloc > &__x, const unordered_multiset< _Value, _Hash, _Pred, _Alloc > &__y)

template<typename _Bi_iter >
bool	operator!= (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)

template<typename _Tp , typename _Alloc >
bool	operator!= (const forward_list< _Tp, _Alloc > &__lx, const forward_list< _Tp, _Alloc > &__ly)

template<class _Key , class _Tp , class _Hash , class _Pred , class _Alloc >
bool	operator!= (const unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > &__x, const unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > &__y)

template<class _Key , class _Tp , class _Hash , class _Pred , class _Alloc >
bool	operator!= (const unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > &__x, const unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > &__y)

template<typename _Tp , typename _Alloc >
bool	operator!= (const vector< _Tp, _Alloc > &__x, const vector< _Tp, _Alloc > &__y)

template<typename _RandomNumberEngine , size_t __k>
bool	operator!= (const std::shuffle_order_engine< _RandomNumberEngine, __k > &__lhs, const std::shuffle_order_engine< _RandomNumberEngine, __k > &__rhs)

template<typename _Tp , typename _Alloc >
bool	operator!= (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)

template<typename _IntType >
bool	operator!= (const std::uniform_int_distribution< _IntType > &__d1, const std::uniform_int_distribution< _IntType > &__d2)

template<typename _Bi_iter , class _Alloc >
bool	operator!= (const match_results< _Bi_iter, _Alloc > &__m1, const match_results< _Bi_iter, _Alloc > &__m2)

template<typename _IntType >
bool	operator!= (const std::uniform_real_distribution< _IntType > &__d1, const std::uniform_real_distribution< _IntType > &__d2)

template<typename _Tp , typename _Alloc >
bool	operator!= (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)

template<typename _RealType >
bool	operator!= (const std::normal_distribution< _RealType > &__d1, const std::normal_distribution< _RealType > &__d2)

template<typename _RealType >
bool	operator!= (const std::lognormal_distribution< _RealType > &__d1, const std::lognormal_distribution< _RealType > &__d2)

template<typename _Res , typename... _Args>
bool	operator!= (const function< _Res(_Args...)> &__f, nullptr_t) noexcept

template<typename _Res , typename... _Args>
bool	operator!= (nullptr_t, const function< _Res(_Args...)> &__f) noexcept

template<typename _CharT , typename _Traits , typename _Alloc >
bool	operator!= (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
bool	operator!= (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
bool	operator!= (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

template<typename _RealType >
bool	operator!= (const std::gamma_distribution< _RealType > &__d1, const std::gamma_distribution< _RealType > &__d2)

template<typename _RealType >
bool	operator!= (const std::chi_squared_distribution< _RealType > &__d1, const std::chi_squared_distribution< _RealType > &__d2)

template<typename _RealType >
bool	operator!= (const std::cauchy_distribution< _RealType > &__d1, const std::cauchy_distribution< _RealType > &__d2)

template<typename _RealType >
bool	operator!= (const std::fisher_f_distribution< _RealType > &__d1, const std::fisher_f_distribution< _RealType > &__d2)

template<typename _RealType >
bool	operator!= (const std::student_t_distribution< _RealType > &__d1, const std::student_t_distribution< _RealType > &__d2)

bool	operator!= (const std::bernoulli_distribution &__d1, const std::bernoulli_distribution &__d2)

template<typename _IntType >
bool	operator!= (const std::binomial_distribution< _IntType > &__d1, const std::binomial_distribution< _IntType > &__d2)

template<typename _IntType >
bool	operator!= (const std::geometric_distribution< _IntType > &__d1, const std::geometric_distribution< _IntType > &__d2)

template<typename _IntType >
bool	operator!= (const std::negative_binomial_distribution< _IntType > &__d1, const std::negative_binomial_distribution< _IntType > &__d2)

template<typename _IntType >
bool	operator!= (const std::poisson_distribution< _IntType > &__d1, const std::poisson_distribution< _IntType > &__d2)

template<typename _RealType >
bool	operator!= (const std::exponential_distribution< _RealType > &__d1, const std::exponential_distribution< _RealType > &__d2)

template<typename _RealType >
bool	operator!= (const std::weibull_distribution< _RealType > &__d1, const std::weibull_distribution< _RealType > &__d2)

template<typename _RealType >
bool	operator!= (const std::extreme_value_distribution< _RealType > &__d1, const std::extreme_value_distribution< _RealType > &__d2)

template<typename _IntType >
bool	operator!= (const std::discrete_distribution< _IntType > &__d1, const std::discrete_distribution< _IntType > &__d2)

template<typename _RealType >
bool	operator!= (const std::piecewise_constant_distribution< _RealType > &__d1, const std::piecewise_constant_distribution< _RealType > &__d2)

template<typename _RealType >
bool	operator!= (const std::piecewise_linear_distribution< _RealType > &__d1, const std::piecewise_linear_distribution< _RealType > &__d2)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __modulus, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun< __modulus, typename _Dom1::value_type > ::result_type >	operator% (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos< __modulus, _Expr, _ValArray, _Dom, typename _Dom::value_type > , typename __fun< __modulus, typename _Dom::value_type > ::result_type >	operator% (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __modulus, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __modulus, typename _Dom::value_type > ::result_type >	operator% (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __modulus, _Expr, _Constant, _Dom, typename _Dom::value_type > , typename __fun< __modulus, typename _Dom::value_type > ::result_type >	operator% (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos< __modulus, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __modulus, typename _Dom::value_type > ::result_type >	operator% (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _BinClos< __modulus, _Constant, _ValArray, _Tp, _Tp > , typename __fun< __modulus, _Tp >::result_type >	operator% (const _Tp &__t, const valarray< _Tp > &__v)

template<typename _Tp >
_Expr< _BinClos< __modulus, _ValArray, _Constant, _Tp, _Tp > , typename __fun< __modulus, _Tp >::result_type >	operator% (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< __modulus, _ValArray, _ValArray, _Tp, _Tp > , typename __fun< __modulus, _Tp >::result_type >	operator% (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

constexpr _Ios_Fmtflags	operator& (_Ios_Fmtflags __a, _Ios_Fmtflags __b)

constexpr memory_order	operator& (memory_order __m, __memory_order_modifier __mod)

constexpr _Ios_Openmode	operator& (_Ios_Openmode __a, _Ios_Openmode __b)

constexpr launch	operator& (launch __x, launch __y)

constexpr _Ios_Iostate	operator& (_Ios_Iostate __a, _Ios_Iostate __b)

template<class _Dom >
_Expr< _BinClos< __bitwise_and, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun < __bitwise_and, typename _Dom::value_type > ::result_type >	operator& (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __bitwise_and, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun < __bitwise_and, typename _Dom1::value_type > ::result_type >	operator& (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos< __bitwise_and, _Expr, _Constant, _Dom, typename _Dom::value_type > , typename __fun < __bitwise_and, typename _Dom::value_type > ::result_type >	operator& (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos< __bitwise_and, _Expr, _ValArray, _Dom, typename _Dom::value_type > , typename __fun < __bitwise_and, typename _Dom::value_type > ::result_type >	operator& (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __bitwise_and, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun < __bitwise_and, typename _Dom::value_type > ::result_type >	operator& (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _BinClos< __bitwise_and, _ValArray, _Constant, _Tp, _Tp > , typename __fun < __bitwise_and, _Tp > ::result_type >	operator& (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< __bitwise_and, _ValArray, _ValArray, _Tp, _Tp > , typename __fun < __bitwise_and, _Tp > ::result_type >	operator& (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<typename _Tp >
_Expr< _BinClos< __bitwise_and, _Constant, _ValArray, _Tp, _Tp > , typename __fun < __bitwise_and, _Tp > ::result_type >	operator& (const _Tp &__t, const valarray< _Tp > &__v)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __logical_and, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun < __logical_and, typename _Dom1::value_type > ::result_type >	operator&& (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos< __logical_and, _Expr, _Constant, _Dom, typename _Dom::value_type > , typename __fun < __logical_and, typename _Dom::value_type > ::result_type >	operator&& (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos< __logical_and, _Expr, _ValArray, _Dom, typename _Dom::value_type > , typename __fun < __logical_and, typename _Dom::value_type > ::result_type >	operator&& (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __logical_and, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun < __logical_and, typename _Dom::value_type > ::result_type >	operator&& (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __logical_and, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun < __logical_and, typename _Dom::value_type > ::result_type >	operator&& (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp >
_Expr< _BinClos< __logical_and, _Constant, _ValArray, _Tp, _Tp > , typename __fun < __logical_and, _Tp > ::result_type >	operator&& (const _Tp &__t, const valarray< _Tp > &__v)

template<typename _Tp >
_Expr< _BinClos< __logical_and, _ValArray, _Constant, _Tp, _Tp > , typename __fun < __logical_and, _Tp > ::result_type >	operator&& (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< __logical_and, _ValArray, _ValArray, _Tp, _Tp > , typename __fun < __logical_and, _Tp > ::result_type >	operator&& (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

const _Ios_Fmtflags &	operator&= (_Ios_Fmtflags &__a, _Ios_Fmtflags __b)

const _Ios_Openmode &	operator&= (_Ios_Openmode &__a, _Ios_Openmode __b)

launch &	operator&= (launch &__x, launch __y)

const _Ios_Iostate &	operator&= (_Ios_Iostate &__a, _Ios_Iostate __b)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __multiplies, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun< __multiplies, typename _Dom1::value_type > ::result_type >	operator* (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos< __multiplies, _Expr, _Constant, _Dom, typename _Dom::value_type > , typename __fun< __multiplies, typename _Dom::value_type > ::result_type >	operator* (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos< __multiplies, _Expr, _ValArray, _Dom, typename _Dom::value_type > , typename __fun< __multiplies, typename _Dom::value_type > ::result_type >	operator* (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __multiplies, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __multiplies, typename _Dom::value_type > ::result_type >	operator* (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<class _Dom >
_Expr< _BinClos< __multiplies, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __multiplies, typename _Dom::value_type > ::result_type >	operator* (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<typename _Tp >
_Expr< _BinClos< __multiplies, _ValArray, _ValArray, _Tp, _Tp > , typename __fun< __multiplies, _Tp >::result_type >	operator* (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<typename _Tp >
_Expr< _BinClos< __multiplies, _ValArray, _Constant, _Tp, _Tp > , typename __fun< __multiplies, _Tp >::result_type >	operator* (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< __multiplies, _Constant, _ValArray, _Tp, _Tp > , typename __fun< __multiplies, _Tp >::result_type >	operator* (const _Tp &__t, const valarray< _Tp > &__v)

_Bit_iterator	operator+ (ptrdiff_t __n, const _Bit_iterator &__x)

template<typename _Iterator >
reverse_iterator< _Iterator >	operator+ (typename reverse_iterator< _Iterator >::difference_type __n, const reverse_iterator< _Iterator > &__x)

template<typename _Tp , typename _Ref , typename _Ptr >
_Deque_iterator< _Tp, _Ref, _Ptr >	operator+ (ptrdiff_t __n, const _Deque_iterator< _Tp, _Ref, _Ptr > &__x) noexcept

_Bit_const_iterator	operator+ (ptrdiff_t __n, const _Bit_const_iterator &__x)

template<class _Dom >
_Expr< _BinClos< __plus, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __plus, typename _Dom::value_type > ::result_type >	operator+ (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<class _Dom >
_Expr< _BinClos< __plus, _Expr, _Constant, _Dom, typename _Dom::value_type >, typename __fun< __plus, typename _Dom::value_type > ::result_type >	operator+ (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __plus, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun< __plus, typename _Dom1::value_type > ::result_type >	operator+ (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos< __plus, _Expr, _ValArray, _Dom, typename _Dom::value_type >, typename __fun< __plus, typename _Dom::value_type > ::result_type >	operator+ (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __plus, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __plus, typename _Dom::value_type > ::result_type >	operator+ (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<typename _Tp >
complex< _Tp >	operator+ (const complex< _Tp > &__x)

template<typename _Iterator >
move_iterator< _Iterator >	operator+ (typename move_iterator< _Iterator >::difference_type __n, const move_iterator< _Iterator > &__x)

template<typename _Tp >
_Expr< _BinClos< __plus, _Constant, _ValArray, _Tp, _Tp > , typename __fun< __plus, _Tp > ::result_type >	operator+ (const _Tp &__t, const valarray< _Tp > &__v)

template<typename _Tp >
_Expr< _BinClos< __plus, _ValArray, _ValArray, _Tp, _Tp > , typename __fun< __plus, _Tp > ::result_type >	operator+ (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<typename _Tp >
_Expr< _BinClos< __plus, _ValArray, _Constant, _Tp, _Tp > , typename __fun< __plus, _Tp > ::result_type >	operator+ (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (_CharT __lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (const basic_string< _CharT, _Traits, _Alloc > &__lhs, _CharT __rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (basic_string< _CharT, _Traits, _Alloc > &&__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (const basic_string< _CharT, _Traits, _Alloc > &__lhs, basic_string< _CharT, _Traits, _Alloc > &&__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (basic_string< _CharT, _Traits, _Alloc > &&__lhs, basic_string< _CharT, _Traits, _Alloc > &&__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (const _CharT *__lhs, basic_string< _CharT, _Traits, _Alloc > &&__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (_CharT __lhs, basic_string< _CharT, _Traits, _Alloc > &&__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (basic_string< _CharT, _Traits, _Alloc > &&__lhs, const _CharT *__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_string< _CharT, _Traits, _Alloc >	operator+ (basic_string< _CharT, _Traits, _Alloc > &&__lhs, _CharT __rhs)

ptrdiff_t	operator- (const _Bit_iterator_base &__x, const _Bit_iterator_base &__y)

template<typename _Iterator >
reverse_iterator< _Iterator > ::difference_type	operator- (const reverse_iterator< _Iterator > &__x, const reverse_iterator< _Iterator > &__y)

template<typename _Tp , typename _Ref , typename _Ptr >
_Deque_iterator< _Tp, _Ref, _Ptr >::difference_type	operator- (const _Deque_iterator< _Tp, _Ref, _Ptr > &__x, const _Deque_iterator< _Tp, _Ref, _Ptr > &__y) noexcept

template<typename _Tp , typename _RefL , typename _PtrL , typename _RefR , typename _PtrR >
_Deque_iterator< _Tp, _RefL, _PtrL >::difference_type	operator- (const _Deque_iterator< _Tp, _RefL, _PtrL > &__x, const _Deque_iterator< _Tp, _RefR, _PtrR > &__y) noexcept

template<typename _IteratorL , typename _IteratorR >
auto	operator- (const reverse_iterator< _IteratorL > &__x, const reverse_iterator< _IteratorR > &__y) -> decltype(__y.base()-__x.base())

template<class _Dom >
_Expr< _BinClos< __minus, _Expr, _ValArray, _Dom, typename _Dom::value_type > , typename __fun< __minus, typename _Dom::value_type > ::result_type >	operator- (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __minus, _Expr, _Constant, _Dom, typename _Dom::value_type > , typename __fun< __minus, typename _Dom::value_type > ::result_type >	operator- (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos< __minus, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __minus, typename _Dom::value_type > ::result_type >	operator- (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __minus, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __minus, typename _Dom::value_type > ::result_type >	operator- (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __minus, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun< __minus, typename _Dom1::value_type > ::result_type >	operator- (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<typename _Tp >
complex< _Tp >	operator- (const complex< _Tp > &__x)

template<typename _IteratorL , typename _IteratorR >
auto	operator- (const move_iterator< _IteratorL > &__x, const move_iterator< _IteratorR > &__y) -> decltype(__x.base()-__y.base())

template<typename _Iterator >
auto	operator- (const move_iterator< _Iterator > &__x, const move_iterator< _Iterator > &__y) -> decltype(__x.base()-__y.base())

template<typename _Tp >
_Expr< _BinClos< __minus, _ValArray, _ValArray, _Tp, _Tp > , typename __fun< __minus, _Tp > ::result_type >	operator- (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<typename _Tp >
_Expr< _BinClos< __minus, _ValArray, _Constant, _Tp, _Tp > , typename __fun< __minus, _Tp > ::result_type >	operator- (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< __minus, _Constant, _ValArray, _Tp, _Tp > , typename __fun< __minus, _Tp > ::result_type >	operator- (const _Tp &__t, const valarray< _Tp > &__v)

template<class _Dom >
_Expr< _BinClos< __divides, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __divides, typename _Dom::value_type > ::result_type >	operator/ (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<class _Dom >
_Expr< _BinClos< __divides, _Expr, _Constant, _Dom, typename _Dom::value_type > , typename __fun< __divides, typename _Dom::value_type > ::result_type >	operator/ (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __divides, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun< __divides, typename _Dom1::value_type > ::result_type >	operator/ (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos< __divides, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __divides, typename _Dom::value_type > ::result_type >	operator/ (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __divides, _Expr, _ValArray, _Dom, typename _Dom::value_type > , typename __fun< __divides, typename _Dom::value_type > ::result_type >	operator/ (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<typename _Tp >
_Expr< _BinClos< __divides, _ValArray, _Constant, _Tp, _Tp > , typename __fun< __divides, _Tp >::result_type >	operator/ (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< __divides, _Constant, _ValArray, _Tp, _Tp > , typename __fun< __divides, _Tp >::result_type >	operator/ (const _Tp &__t, const valarray< _Tp > &__v)

template<typename _Tp >
_Expr< _BinClos< __divides, _ValArray, _ValArray, _Tp, _Tp > , typename __fun< __divides, _Tp >::result_type >	operator/ (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

bool	operator< (const error_code &__lhs, const error_code &__rhs) noexcept

template<class _T1 , class _T2 >
constexpr bool	operator< (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)

template<typename _Tp , std::size_t _Nm>
bool	operator< (const array< _Tp, _Nm > &__a, const array< _Tp, _Nm > &__b)

bool	operator< (const error_condition &__lhs, const error_condition &__rhs) noexcept

template<typename _Tp , typename _Seq >
bool	operator< (const stack< _Tp, _Seq > &__x, const stack< _Tp, _Seq > &__y)

template<typename _Tp , typename _Ref , typename _Ptr >
bool	operator< (const _Deque_iterator< _Tp, _Ref, _Ptr > &__x, const _Deque_iterator< _Tp, _Ref, _Ptr > &__y) noexcept

template<typename _Tp , typename _RefL , typename _PtrL , typename _RefR , typename _PtrR >
bool	operator< (const _Deque_iterator< _Tp, _RefL, _PtrL > &__x, const _Deque_iterator< _Tp, _RefR, _PtrR > &__y) noexcept

template<typename _Tp , typename _Seq >
bool	operator< (const queue< _Tp, _Seq > &__x, const queue< _Tp, _Seq > &__y)

template<typename _Iterator >
bool	operator< (const reverse_iterator< _Iterator > &__x, const reverse_iterator< _Iterator > &__y)

template<typename _IteratorL , typename _IteratorR >
bool	operator< (const reverse_iterator< _IteratorL > &__x, const reverse_iterator< _IteratorR > &__y)

template<typename _Tp1 , typename _Tp2 >
bool	operator< (const shared_ptr< _Tp1 > &__a, const shared_ptr< _Tp2 > &__b) noexcept

template<typename _Tp >
bool	operator< (const shared_ptr< _Tp > &__a, nullptr_t) noexcept

template<typename _Tp >
bool	operator< (nullptr_t, const shared_ptr< _Tp > &__a) noexcept

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __less, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun< __less, typename _Dom1::value_type > ::result_type >	operator< (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos< __less, _Expr, _Constant, _Dom, typename _Dom::value_type >, typename __fun< __less, typename _Dom::value_type > ::result_type >	operator< (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos< __less, _Expr, _ValArray, _Dom, typename _Dom::value_type >, typename __fun< __less, typename _Dom::value_type > ::result_type >	operator< (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __less, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __less, typename _Dom::value_type > ::result_type >	operator< (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __less, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __less, typename _Dom::value_type > ::result_type >	operator< (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool	operator< (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _Tp , typename _Dp >
bool	operator< (const unique_ptr< _Tp, _Dp > &__x, nullptr_t)

template<typename _Tp , typename _Dp >
bool	operator< (nullptr_t, const unique_ptr< _Tp, _Dp > &__x)

template<typename _Key , typename _Compare , typename _Alloc >
bool	operator< (const multiset< _Key, _Compare, _Alloc > &__x, const multiset< _Key, _Compare, _Alloc > &__y)

template<typename _Key , typename _Compare , typename _Alloc >
bool	operator< (const set< _Key, _Compare, _Alloc > &__x, const set< _Key, _Compare, _Alloc > &__y)

template<typename... _TElements, typename... _UElements>
constexpr bool	operator< (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)

template<typename _Key , typename _Tp , typename _Compare , typename _Alloc >
bool	operator< (const multimap< _Key, _Tp, _Compare, _Alloc > &__x, const multimap< _Key, _Tp, _Compare, _Alloc > &__y)

template<typename _BiIter >
bool	operator< (const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)

template<typename _Key , typename _Val , typename _KeyOfValue , typename _Compare , typename _Alloc >
bool	operator< (const _Rb_tree< _Key, _Val, _KeyOfValue, _Compare, _Alloc > &__x, const _Rb_tree< _Key, _Val, _KeyOfValue, _Compare, _Alloc > &__y)

template<typename _Bi_iter , typename _Ch_traits , typename _Ch_alloc >
bool	operator< (const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)

template<typename _Key , typename _Tp , typename _Compare , typename _Alloc >
bool	operator< (const map< _Key, _Tp, _Compare, _Alloc > &__x, const map< _Key, _Tp, _Compare, _Alloc > &__y)

template<typename _Bi_iter , class _Ch_traits , class _Ch_alloc >
bool	operator< (const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)

template<typename _IteratorL , typename _IteratorR >
bool	operator< (const move_iterator< _IteratorL > &__x, const move_iterator< _IteratorR > &__y)

template<typename _Iterator >
bool	operator< (const move_iterator< _Iterator > &__x, const move_iterator< _Iterator > &__y)

template<typename _Tp1 , typename _Tp2 , _Lock_policy _Lp>
bool	operator< (const __shared_ptr< _Tp1, _Lp > &__a, const __shared_ptr< _Tp2, _Lp > &__b) noexcept

template<typename _Bi_iter >
bool	operator< (typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)

template<typename _Tp , _Lock_policy _Lp>
bool	operator< (const __shared_ptr< _Tp, _Lp > &__a, nullptr_t) noexcept

template<typename _Tp , _Lock_policy _Lp>
bool	operator< (nullptr_t, const __shared_ptr< _Tp, _Lp > &__a) noexcept

template<typename _Tp >
_Expr< _BinClos< __less, _Constant, _ValArray, _Tp, _Tp > , typename __fun< __less, _Tp > ::result_type >	operator< (const _Tp &__t, const valarray< _Tp > &__v)

template<typename _Tp >
_Expr< _BinClos< __less, _ValArray, _Constant, _Tp, _Tp > , typename __fun< __less, _Tp > ::result_type >	operator< (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< __less, _ValArray, _ValArray, _Tp, _Tp > , typename __fun< __less, _Tp > ::result_type >	operator< (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<typename _Bi_iter >
bool	operator< (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)

template<typename _Bi_iter >
bool	operator< (typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)

template<typename _Tp , typename _Alloc >
bool	operator< (const forward_list< _Tp, _Alloc > &__lx, const forward_list< _Tp, _Alloc > &__ly)

template<typename _Bi_iter >
bool	operator< (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)

template<typename _Tp , typename _Alloc >
bool	operator< (const vector< _Tp, _Alloc > &__x, const vector< _Tp, _Alloc > &__y)

template<typename _Tp , typename _Alloc >
bool	operator< (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)

template<typename _Tp , typename _Alloc >
bool	operator< (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)

template<typename _CharT , typename _Traits , typename _Alloc >
bool	operator< (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
bool	operator< (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
bool	operator< (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, _Resetiosflags __f)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, _Setiosflags __f)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, _Setbase __f)

template<typename _UIntType , _UIntType __a, _UIntType __c, _UIntType __m, typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const linear_congruential_engine< _UIntType, __a, __c, __m > &__lcr)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, _Setfill< _CharT > __f)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, const error_code &__e)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, _Setprecision __f)

template<class _CharT , class _Traits >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__out, thread::id __id)

template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, _Setw __f)

template<typename _CharT , typename _Traits , typename _MoneyT >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, _Put_money< _MoneyT > __f)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __shift_left, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun< __shift_left, typename _Dom1::value_type > ::result_type >	operator<< (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos< __shift_left, _Expr, _ValArray, _Dom, typename _Dom::value_type > , typename __fun< __shift_left, typename _Dom::value_type > ::result_type >	operator<< (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __shift_left, _Expr, _Constant, _Dom, typename _Dom::value_type > , typename __fun< __shift_left, typename _Dom::value_type > ::result_type >	operator<< (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos< __shift_left, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __shift_left, typename _Dom::value_type > ::result_type >	operator<< (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<class _Dom >
_Expr< _BinClos< __shift_left, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __shift_left, typename _Dom::value_type > ::result_type >	operator<< (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<typename _UIntType , size_t __w, size_t __n, size_t __m, size_t __r, _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f, typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const mersenne_twister_engine< _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f > &__x)

template<typename _Tp , typename _CharT , class _Traits >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, const complex< _Tp > &__x)

template<typename _Ch , typename _Tr , typename _Tp , _Lock_policy _Lp>
std::basic_ostream< _Ch, _Tr > &	operator<< (std::basic_ostream< _Ch, _Tr > &__os, const __shared_ptr< _Tp, _Lp > &__p)

template<typename _CharT , typename _Traits , typename _Tp >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &&__os, const _Tp &__x)

template<typename _UIntType , size_t __w, size_t __s, size_t __r, typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const subtract_with_carry_engine< _UIntType, __w, __s, __r > &__x)

template<typename _RandomNumberEngine , size_t __p, size_t __r, typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const discard_block_engine< _RandomNumberEngine, __p, __r > &__x)

template<typename _RandomNumberEngine , size_t __k, typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const shuffle_order_engine< _RandomNumberEngine, __k > &__x)

template<typename _Tp >
_Expr< _BinClos< __shift_left, _ValArray, _Constant, _Tp, _Tp > , typename __fun< __shift_left, _Tp >::result_type >	operator<< (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< __shift_left, _Constant, _ValArray, _Tp, _Tp > , typename __fun< __shift_left, _Tp >::result_type >	operator<< (const _Tp &__t, const valarray< _Tp > &__v)

template<typename _Tp >
_Expr< _BinClos< __shift_left, _ValArray, _ValArray, _Tp, _Tp > , typename __fun< __shift_left, _Tp >::result_type >	operator<< (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<typename _RandomNumberEngine , size_t __w, typename _UIntType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::independent_bits_engine< _RandomNumberEngine, __w, _UIntType > &__x)

template<typename _IntType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const negative_binomial_distribution< _IntType > &__x)

template<typename _Ch_type , typename _Ch_traits , typename _Bi_iter >
basic_ostream< _Ch_type, _Ch_traits > &	operator<< (basic_ostream< _Ch_type, _Ch_traits > &__os, const sub_match< _Bi_iter > &__m)

template<typename _IntType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const poisson_distribution< _IntType > &__x)

template<typename _IntType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const binomial_distribution< _IntType > &__x)

template<typename _IntType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &, const std::uniform_int_distribution< _IntType > &)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const normal_distribution< _RealType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &, const std::uniform_real_distribution< _RealType > &)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const lognormal_distribution< _RealType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const chi_squared_distribution< _RealType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const fisher_f_distribution< _RealType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const student_t_distribution< _RealType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const gamma_distribution< _RealType > &__x)

template<typename _CharT , typename _Traits , typename _Alloc , template< typename, typename, typename > class _Base>
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base > &__str)

template<typename _CharT , typename _Traits , typename _Alloc >
basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, const basic_string< _CharT, _Traits, _Alloc > &__str)

template<typename _IntType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const discrete_distribution< _IntType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const piecewise_constant_distribution< _RealType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::cauchy_distribution< _RealType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const piecewise_linear_distribution< _RealType > &__x)

template<typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::bernoulli_distribution &__x)

template<typename _IntType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::geometric_distribution< _IntType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::exponential_distribution< _RealType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::weibull_distribution< _RealType > &__x)

template<typename _RealType , typename _CharT , typename _Traits >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::extreme_value_distribution< _RealType > &__x)

bool	operator<= (thread::id __x, thread::id __y) noexcept

template<class _T1 , class _T2 >
constexpr bool	operator<= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)

template<typename _Tp , std::size_t _Nm>
bool	operator<= (const array< _Tp, _Nm > &__one, const array< _Tp, _Nm > &__two)

template<typename _Tp , typename _Seq >
bool	operator<= (const stack< _Tp, _Seq > &__x, const stack< _Tp, _Seq > &__y)

template<typename _Tp , typename _Seq >
bool	operator<= (const queue< _Tp, _Seq > &__x, const queue< _Tp, _Seq > &__y)

template<typename _Tp , typename _Ref , typename _Ptr >
bool	operator<= (const _Deque_iterator< _Tp, _Ref, _Ptr > &__x, const _Deque_iterator< _Tp, _Ref, _Ptr > &__y) noexcept

template<typename _Tp , typename _RefL , typename _PtrL , typename _RefR , typename _PtrR >
bool	operator<= (const _Deque_iterator< _Tp, _RefL, _PtrL > &__x, const _Deque_iterator< _Tp, _RefR, _PtrR > &__y) noexcept

template<typename _Iterator >
bool	operator<= (const reverse_iterator< _Iterator > &__x, const reverse_iterator< _Iterator > &__y)

template<typename _IteratorL , typename _IteratorR >
bool	operator<= (const reverse_iterator< _IteratorL > &__x, const reverse_iterator< _IteratorR > &__y)

template<typename _Tp1 , typename _Tp2 >
bool	operator<= (const shared_ptr< _Tp1 > &__a, const shared_ptr< _Tp2 > &__b) noexcept

template<typename _Tp >
bool	operator<= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept

template<typename _Tp >
bool	operator<= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept

template<class _Dom >
_Expr< _BinClos< __less_equal, _Expr, _Constant, _Dom, typename _Dom::value_type > , typename __fun< __less_equal, typename _Dom::value_type > ::result_type >	operator<= (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos< __less_equal, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __less_equal, typename _Dom::value_type > ::result_type >	operator<= (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __less_equal, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __less_equal, typename _Dom::value_type > ::result_type >	operator<= (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<class _Dom >
_Expr< _BinClos< __less_equal, _Expr, _ValArray, _Dom, typename _Dom::value_type > , typename __fun< __less_equal, typename _Dom::value_type > ::result_type >	operator<= (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __less_equal, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun< __less_equal, typename _Dom1::value_type > ::result_type >	operator<= (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool	operator<= (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _Tp , typename _Dp >
bool	operator<= (const unique_ptr< _Tp, _Dp > &__x, nullptr_t)

template<typename _Tp , typename _Dp >
bool	operator<= (nullptr_t, const unique_ptr< _Tp, _Dp > &__x)

template<typename _Key , typename _Compare , typename _Alloc >
bool	operator<= (const multiset< _Key, _Compare, _Alloc > &__x, const multiset< _Key, _Compare, _Alloc > &__y)

template<typename _Key , typename _Compare , typename _Alloc >
bool	operator<= (const set< _Key, _Compare, _Alloc > &__x, const set< _Key, _Compare, _Alloc > &__y)

template<typename... _TElements, typename... _UElements>
constexpr bool	operator<= (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)

template<typename _BiIter >
bool	operator<= (const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)

template<typename _Key , typename _Tp , typename _Compare , typename _Alloc >
bool	operator<= (const multimap< _Key, _Tp, _Compare, _Alloc > &__x, const multimap< _Key, _Tp, _Compare, _Alloc > &__y)

template<typename _Key , typename _Val , typename _KeyOfValue , typename _Compare , typename _Alloc >
bool	operator<= (const _Rb_tree< _Key, _Val, _KeyOfValue, _Compare, _Alloc > &__x, const _Rb_tree< _Key, _Val, _KeyOfValue, _Compare, _Alloc > &__y)

template<typename _Key , typename _Tp , typename _Compare , typename _Alloc >
bool	operator<= (const map< _Key, _Tp, _Compare, _Alloc > &__x, const map< _Key, _Tp, _Compare, _Alloc > &__y)

template<typename _Bi_iter , typename _Ch_traits , typename _Ch_alloc >
bool	operator<= (const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)

template<typename _IteratorL , typename _IteratorR >
bool	operator<= (const move_iterator< _IteratorL > &__x, const move_iterator< _IteratorR > &__y)

template<typename _Iterator >
bool	operator<= (const move_iterator< _Iterator > &__x, const move_iterator< _Iterator > &__y)

template<typename _Bi_iter , class _Ch_traits , class _Ch_alloc >
bool	operator<= (const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)

template<typename _Tp1 , typename _Tp2 , _Lock_policy _Lp>
bool	operator<= (const __shared_ptr< _Tp1, _Lp > &__a, const __shared_ptr< _Tp2, _Lp > &__b) noexcept

template<typename _Tp , _Lock_policy _Lp>
bool	operator<= (const __shared_ptr< _Tp, _Lp > &__a, nullptr_t) noexcept

template<typename _Tp , _Lock_policy _Lp>
bool	operator<= (nullptr_t, const __shared_ptr< _Tp, _Lp > &__a) noexcept

template<typename _Tp >
_Expr< _BinClos< __less_equal, _ValArray, _Constant, _Tp, _Tp > , typename __fun< __less_equal, _Tp >::result_type >	operator<= (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< __less_equal, _ValArray, _ValArray, _Tp, _Tp > , typename __fun< __less_equal, _Tp >::result_type >	operator<= (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<typename _Tp >
_Expr< _BinClos< __less_equal, _Constant, _ValArray, _Tp, _Tp > , typename __fun< __less_equal, _Tp >::result_type >	operator<= (const _Tp &__t, const valarray< _Tp > &__v)

template<typename _Bi_iter >
bool	operator<= (typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)

template<typename _Bi_iter >
bool	operator<= (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)

template<typename _Bi_iter >
bool	operator<= (typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)

template<typename _Tp , typename _Alloc >
bool	operator<= (const forward_list< _Tp, _Alloc > &__lx, const forward_list< _Tp, _Alloc > &__ly)

template<typename _Bi_iter >
bool	operator<= (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)

template<typename _Tp , typename _Alloc >
bool	operator<= (const vector< _Tp, _Alloc > &__x, const vector< _Tp, _Alloc > &__y)

template<typename _Tp , typename _Alloc >
bool	operator<= (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)

template<typename _Tp , typename _Alloc >
bool	operator<= (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)

template<typename _CharT , typename _Traits , typename _Alloc >
bool	operator<= (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
bool	operator<= (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

template<typename _CharT , typename _Traits , typename _Alloc >
bool	operator<= (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

template<typename _T1 , typename _T2 >
bool	operator== (const allocator< _T1 > &, const allocator< _T2 > &)

template<typename _Tp , typename _CharT , typename _Traits , typename _Dist >
bool	operator== (const istream_iterator< _Tp, _CharT, _Traits, _Dist > &__x, const istream_iterator< _Tp, _CharT, _Traits, _Dist > &__y)

template<typename _Tp >
bool	operator== (const allocator< _Tp > &, const allocator< _Tp > &)

template<typename _CharT , typename _Traits >
bool	operator== (const istreambuf_iterator< _CharT, _Traits > &__a, const istreambuf_iterator< _CharT, _Traits > &__b)

template<class _T1 , class _T2 >
constexpr bool	operator== (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)

template<typename _StateT >
bool	operator== (const fpos< _StateT > &__lhs, const fpos< _StateT > &__rhs)

template<typename _Tp , std::size_t _Nm>
bool	operator== (const array< _Tp, _Nm > &__one, const array< _Tp, _Nm > &__two)

template<typename _Tp , typename _Seq >
bool	operator== (const stack< _Tp, _Seq > &__x, const stack< _Tp, _Seq > &__y)

template<typename _Tp , typename _Ref , typename _Ptr >
bool	operator== (const _Deque_iterator< _Tp, _Ref, _Ptr > &__x, const _Deque_iterator< _Tp, _Ref, _Ptr > &__y) noexcept

template<typename _Tp >
bool	operator== (const _Fwd_list_iterator< _Tp > &__x, const _Fwd_list_const_iterator< _Tp > &__y) noexcept

template<typename _Tp , typename _RefL , typename _PtrL , typename _RefR , typename _PtrR >
bool	operator== (const _Deque_iterator< _Tp, _RefL, _PtrL > &__x, const _Deque_iterator< _Tp, _RefR, _PtrR > &__y) noexcept

bool	operator== (const error_code &__lhs, const error_code &__rhs) noexcept

bool	operator== (const error_code &__lhs, const error_condition &__rhs) noexcept

template<typename _Tp , typename _Seq >
bool	operator== (const queue< _Tp, _Seq > &__x, const queue< _Tp, _Seq > &__y)

bool	operator== (const error_condition &__lhs, const error_code &__rhs) noexcept

bool	operator== (const error_condition &__lhs, const error_condition &__rhs) noexcept

template<typename _Val >
bool	operator== (const _List_iterator< _Val > &__x, const _List_const_iterator< _Val > &__y) noexcept

template<typename _Iterator >
bool	operator== (const reverse_iterator< _Iterator > &__x, const reverse_iterator< _Iterator > &__y)

template<typename _Val >
bool	operator== (const _Rb_tree_iterator< _Val > &__x, const _Rb_tree_const_iterator< _Val > &__y) noexcept

template<typename _Tp1 , typename _Tp2 >
bool	operator== (const shared_ptr< _Tp1 > &__a, const shared_ptr< _Tp2 > &__b) noexcept

template<typename _Tp >
bool	operator== (const shared_ptr< _Tp > &__a, nullptr_t) noexcept

template<typename _Tp >
bool	operator== (nullptr_t, const shared_ptr< _Tp > &__a) noexcept

template<typename _IteratorL , typename _IteratorR >
bool	operator== (const reverse_iterator< _IteratorL > &__x, const reverse_iterator< _IteratorR > &__y)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< __equal_to, _Expr, _Expr, _Dom1, _Dom2 > , typename __fun< __equal_to, typename _Dom1::value_type > ::result_type >	operator== (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos< __equal_to, _Expr, _Constant, _Dom, typename _Dom::value_type > , typename __fun< __equal_to, typename _Dom::value_type > ::result_type >	operator== (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom >
_Expr< _BinClos< __equal_to, _Expr, _ValArray, _Dom, typename _Dom::value_type > , typename __fun< __equal_to, typename _Dom::value_type > ::result_type >	operator== (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __equal_to, _Constant, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __equal_to, typename _Dom::value_type > ::result_type >	operator== (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< __equal_to, _ValArray, _Expr, typename _Dom::value_type, _Dom > , typename __fun< __equal_to, typename _Dom::value_type > ::result_type >	operator== (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename _OutA1 , typename _OutA2 , typename... _InA>
bool	operator== (const scoped_allocator_adaptor< _OutA1, _InA...> &__a, const scoped_allocator_adaptor< _OutA2, _InA...> &__b) noexcept

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool	operator== (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _Tp , typename _Dp >
bool	operator== (const unique_ptr< _Tp, _Dp > &__x, nullptr_t) noexcept

template<typename _Tp , typename _Dp >
bool	operator== (nullptr_t, const unique_ptr< _Tp, _Dp > &__x) noexcept

template<typename _Key , typename _Compare , typename _Alloc >
bool	operator== (const multiset< _Key, _Compare, _Alloc > &__x, const multiset< _Key, _Compare, _Alloc > &__y)

template<typename _Key , typename _Compare , typename _Alloc >
bool	operator== (const set< _Key, _Compare, _Alloc > &__x, const set< _Key, _Compare, _Alloc > &__y)

template<typename... _TElements, typename... _UElements>
constexpr bool	operator== (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)

template<typename _Key , typename _Tp , typename _Compare , typename _Alloc >
bool	operator== (const multimap< _Key, _Tp, _Compare, _Alloc > &__x, const multimap< _Key, _Tp, _Compare, _Alloc > &__y)

template<typename _BiIter >
bool	operator== (const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)

template<typename _Key , typename _Val , typename _KeyOfValue , typename _Compare , typename _Alloc >
bool	operator== (const _Rb_tree< _Key, _Val, _KeyOfValue, _Compare, _Alloc > &__x, const _Rb_tree< _Key, _Val, _KeyOfValue, _Compare, _Alloc > &__y)

template<typename _Bi_iter , typename _Ch_traits , typename _Ch_alloc >
bool	operator== (const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)

template<typename _Key , typename _Tp , typename _Compare , typename _Alloc >
bool	operator== (const map< _Key, _Tp, _Compare, _Alloc > &__x, const map< _Key, _Tp, _Compare, _Alloc > &__y)

template<typename _Bi_iter , typename _Ch_traits , typename _Ch_alloc >
bool	operator== (const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)

template<typename _IteratorL , typename _IteratorR >
bool	operator== (const move_iterator< _IteratorL > &__x, const move_iterator< _IteratorR > &__y)

template<typename _Iterator >
bool	operator== (const move_iterator< _Iterator > &__x, const move_iterator< _Iterator > &__y)

template<typename _Tp1 , typename _Tp2 , _Lock_policy _Lp>
bool	operator== (const __shared_ptr< _Tp1, _Lp > &__a, const __shared_ptr< _Tp2, _Lp > &__b) noexcept

template<typename _Tp , _Lock_policy _Lp>
bool	operator== (const __shared_ptr< _Tp, _Lp > &__a, nullptr_t) noexcept

template<typename _Tp , _Lock_policy _Lp>
bool	operator== (nullptr_t, const __shared_ptr< _Tp, _Lp > &__a) noexcept

template<typename _Bi_iter >
bool	operator== (typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)

template<typename _Tp >
_Expr< _BinClos< __equal_to, _ValArray, _Constant, _Tp, _Tp > , typename __fun< __equal_to, _Tp >::result_type >	operator== (const valarray< _Tp > &__v, const _Tp &__t)

template<typename _Tp >
_Expr< _BinClos< __equal_to, _Constant, _ValArray, _Tp, _Tp > , typename __fun< __equal_to, _Tp >::result_type >	operator== (const _Tp &__t, const valarray< _Tp > &__v)

template<typename _Tp >
_Expr< _BinClos< __equal_to, _ValArray, _ValArray, _Tp, _Tp > , typename __fun< __equal_to, _Tp >::result_type >	operator== (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<typename _Bi_iter >
bool	operator== (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)

template<typename _Bi_iter >
bool	operator== (typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)

template<class _Value , class _Hash , class _Pred , class _Alloc >
bool	operator== (const unordered_set< _Value, _Hash, _Pred, _Alloc > &__x, const unordered_set< _Value, _Hash, _Pred, _Alloc > &__y)

template<class _Value , class _Hash , class _Pred , class _Alloc >
bool	operator== (const unordered_multiset< _Value, _Hash, _Pred, _Alloc > &__x, const unordered_multiset< _Value, _Hash, _Pred, _Alloc > &__y)

template<typename _Tp , typename _Alloc >
bool	operator== (const forward_list< _Tp, _Alloc > &__lx, const forward_list< _Tp, _Alloc > &__ly)

template<typename _Bi_iter >
bool	operator== (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)

template<class _Key , class _Tp , class _Hash , class _Pred , class _Alloc >
bool	operator== (const unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > &__x, const unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > &__y)

template<class _Key , class _Tp , class _Hash , class _Pred , class _Alloc >
bool	operator== (const unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > &__x, const unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > &__y)

template<typename _Tp , typename _Alloc >
bool	operator== (const vector< _Tp, _Alloc > &__x, const vector< _Tp, _Alloc > &__y)

template<typename _Tp , typename _Alloc >
bool	operator== (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)

template<typename _Bi_iter , typename _Alloc >
bool	operator== (const match_results< _Bi_iter, _Alloc > &__m1, const match_results< _Bi_iter, _Alloc > &__m2)

template<typename _Tp , typename _Alloc >
bool	operator== (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)

template<typename _RealType >
bool	operator== (const std::normal_distribution< _RealType > &__d1, const std::normal_distribution< _RealType > &__d2)

template<typename _Res , typename... _Args>
bool	operator== (const function< _Res(_Args...)> &__f, nullptr_t) noexcept

templ

Namespaces

Classes

Typedefs

Enumerations

Functions