Namespaces

Classes
struct	__allocated_ptr

struct	__atomic_base

struct	__atomic_base< _PTp *>

struct	__atomic_flag_base

class	__basic_future

class	__codecvt_abstract_base

class	__ctype_abstract_base

struct	__future_base

struct	__is_location_invariant

struct	__is_nullptr_t

struct	__is_tuple_like_impl< std::pair< _T1, _T2 > >

struct	__iterator_traits

struct	__numeric_limits_base

class	__shared_mutex_cv

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 >

class	_Mu

class	_Mu< _Arg, false, false >

class	_Mu< _Arg, false, true >

class	_Mu< _Arg, true, false >

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

class	_Not_fn

struct	_Placeholder

struct	_Reference_wrapper_base

struct	_Sp_ebo_helper< _Nm, _Tp, false >

struct	_Sp_ebo_helper< _Nm, _Tp, true >

class	_Temporary_buffer

struct	_Tuple_impl

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	allocator_traits< allocator< _Tp > >

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_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	bitset

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< char16_t, char, mbstate_t >

class	codecvt< char32_t, 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

struct	divides< void >

class	domain_error

class	enable_shared_from_this

struct	equal_to

struct	equal_to< void >

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

class	future< _Res &>

class	future< void >

class	future_error

class	gamma_distribution

class	geometric_distribution

struct	greater

struct	greater< void >

struct	greater_equal

struct	greater_equal< void >

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< experimental::shared_ptr< _Tp > >

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	integer_sequence

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_final

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

struct	less_equal

struct	less_equal< void >

class	linear_congruential_engine

class	list

class	locale

class	lock_guard

class	logic_error

struct	logical_and

struct	logical_and< void >

struct	logical_not

struct	logical_not< void >

struct	logical_or

struct	logical_or< void >

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	minus< void >

struct	modulus

struct	modulus< void >

class	money_base

class	money_get

class	money_put

class	moneypunct

class	moneypunct_byname

class	move_iterator

class	multimap

struct	multiplies

struct	multiplies< void >

class	multiset

class	mutex

struct	negate

struct	negate< void >

class	negative_binomial_distribution

class	nested_exception

class	normal_distribution

struct	not_equal_to

struct	not_equal_to< void >

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

struct	owner_less< weak_ptr< _Tp > >

class	packaged_task< _Res(_ArgTypes...)>

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	promise

class	promise< _Res &>

class	promise< void >

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	recursive_timed_mutex

class	reference_wrapper

class	regex_error

class	regex_iterator

class	regex_token_iterator

class	regex_traits

class	reverse_iterator

class	runtime_error

class	scoped_allocator_adaptor

class	seed_seq

class	set

class	shared_future

class	shared_future< _Res &>

class	shared_future< void >

class	shared_lock

class	shared_ptr

class	shared_timed_mutex

class	shuffle_order_engine

class	slice

class	slice_array

class	stack

class	student_t_distribution

class	sub_match

class	subtract_with_carry_engine

class	system_error

class	thread

class	time_base

class	time_get

class	time_get_byname

class	time_put

class	time_put_byname

class	timed_mutex

struct	try_to_lock_t

class	tuple

class	tuple< _T1, _T2 >

struct	tuple_element

struct	tuple_element< 0, std::pair< _Tp1, _Tp2 > >

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

struct	tuple_element< 1, std::pair< _Tp1, _Tp2 > >

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

struct	tuple_element< __i, tuple<> >

struct	tuple_element< _Int, ::array< _Tp, _Nm > >

struct	tuple_element< _Int, std::__debug::array< _Tp, _Nm > >

struct	tuple_size

struct	tuple_size< std::__debug::array< _Tp, _Nm > >

struct	tuple_size< std::pair< _Tp1, _Tp2 > >

struct	tuple_size< tuple< _Elements... > >

struct	tuple_size<::array< _Tp, _Nm > >

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	wbuffer_convert

class	weak_ptr

class	weibull_distribution

class	wstring_convert

Typedefs
typedef __gnu_cxx::new_allocator< _Tp >	__allocator_base

typedef typename pointer_traits< _Ptr >::template rebind< _Tp >	__ptr_rebind

typedef __detail::_Hashtable_traits< _Cache, false, true >	__umap_traits

typedef __detail::_Hashtable_traits< _Cache, false, false >	__ummap_traits

typedef __detail::_Hashtable_traits< _Cache, true, false >	__umset_traits

typedef __detail::_Hashtable_traits< _Cache, true, true >	__uset_traits

typedef atomic< bool >	atomic_bool

typedef atomic< char >	atomic_char

typedef atomic< char16_t >	atomic_char16_t

typedef atomic< char32_t >	atomic_char32_t

typedef atomic< int >	atomic_int

typedef atomic< int16_t >	atomic_int16_t

typedef atomic< int32_t >	atomic_int32_t

typedef atomic< int64_t >	atomic_int64_t

typedef atomic< int8_t >	atomic_int8_t

typedef atomic< int_fast16_t >	atomic_int_fast16_t

typedef atomic< int_fast32_t >	atomic_int_fast32_t

typedef atomic< int_fast64_t >	atomic_int_fast64_t

typedef atomic< int_fast8_t >	atomic_int_fast8_t

typedef atomic< int_least16_t >	atomic_int_least16_t

typedef atomic< int_least32_t >	atomic_int_least32_t

typedef atomic< int_least64_t >	atomic_int_least64_t

typedef atomic< int_least8_t >	atomic_int_least8_t

typedef atomic< intmax_t >	atomic_intmax_t

typedef atomic< intptr_t >	atomic_intptr_t

typedef atomic< long long >	atomic_llong

typedef atomic< long >	atomic_long

typedef atomic< ptrdiff_t >	atomic_ptrdiff_t

typedef atomic< signed char >	atomic_schar

typedef atomic< short >	atomic_short

typedef atomic< size_t >	atomic_size_t

typedef atomic< unsigned char >	atomic_uchar

typedef atomic< unsigned int >	atomic_uint

typedef atomic< uint16_t >	atomic_uint16_t

typedef atomic< uint32_t >	atomic_uint32_t

typedef atomic< uint64_t >	atomic_uint64_t

typedef atomic< uint8_t >	atomic_uint8_t

typedef atomic< uint_fast16_t >	atomic_uint_fast16_t

typedef atomic< uint_fast32_t >	atomic_uint_fast32_t

typedef atomic< uint_fast64_t >	atomic_uint_fast64_t

typedef atomic< uint_fast8_t >	atomic_uint_fast8_t

typedef atomic< uint_least16_t >	atomic_uint_least16_t

typedef atomic< uint_least32_t >	atomic_uint_least32_t

typedef atomic< uint_least64_t >	atomic_uint_least64_t

typedef atomic< uint_least8_t >	atomic_uint_least8_t

typedef atomic< uintmax_t >	atomic_uintmax_t

typedef atomic< uintptr_t >	atomic_uintptr_t

typedef atomic< unsigned long long >	atomic_ullong

typedef atomic< unsigned long >	atomic_ulong

typedef atomic< unsigned short >	atomic_ushort

typedef atomic< wchar_t >	atomic_wchar_t

typedef regex_token_iterator< const char *>	cregex_token_iterator

typedef sub_match< const char *>	csub_match

typedef integral_constant< bool, false >	false_type

typedef basic_filebuf< char >	filebuf

typedef basic_fstream< char >	fstream

typedef basic_ifstream< char >	ifstream

typedef integer_sequence< size_t, _Idx... >	index_sequence

typedef make_index_sequence< sizeof...(_Types)>	index_sequence_for

typedef basic_ios< char >	ios

typedef basic_iostream< char >	iostream

typedef basic_istream< char >	istream

typedef basic_istringstream< char >	istringstream

typedef make_integer_sequence< size_t, _Num >	make_index_sequence

typedef typename _Make_integer_sequence< _Tp, _Num >::__type	make_integer_sequence

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 typename __ratio_divide< _R1, _R2 >::type	ratio_divide

typedef typename __ratio_multiply< _R1, _R2 >::type	ratio_multiply

typedef basic_regex< char >	regex

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

typedef __shared_mutex_cv	__shared_timed_mutex_base

Enumerations
enum	cv_status { no_timeout, timeout }

enum	float_denorm_style

enum	float_round_style

enum	future_errc { future_already_retrieved, promise_already_satisfied, no_state, broken_promise }

enum	future_status { ready, timeout, deferred }

enum	io_errc { stream }

enum	launch { async, deferred }

enum	memory_order

Functions
constexpr _Tp *	__addressof (_Tp &__r) noexcept

__allocated_ptr< _Alloc >	__allocate_guarded (_Alloc &__a)

void	__final_insertion_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

_InputIterator	__find_if (_InputIterator __first, _InputIterator __last, _Predicate __pred, input_iterator_tag)

_RandomAccessIterator	__find_if (_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate __pred, random_access_iterator_tag)

_InputIterator	__find_if_not (_InputIterator __first, _InputIterator __last, _Predicate __pred)

_InputIterator	__find_if_not_n (_InputIterator __first, _Distance &__len, _Predicate __pred)

_EuclideanRingElement	__gcd (_EuclideanRingElement __m, _EuclideanRingElement __n)

pair< _IntType, _IntType >	__gen_two_uniform_ints (_IntType __b0, _IntType __b1, _UniformRandomBitGenerator &&__g)

void	__heap_select (_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp)

void	__inplace_stable_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

void	__insertion_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

void	__introsort_loop (_RandomAccessIterator __first, _RandomAccessIterator __last, _Size __depth_limit, _Compare __comp)

constexpr __invoke_result< _Callable, _Args... >::type	__invoke (_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)

constexpr iterator_traits< _Iter >::iterator_category	__iterator_category (const _Iter &)

constexpr int	__lg (int __n)

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

void	__merge_without_buffer (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Compare __comp)

void	__move_median_to_first (_Iterator __result, _Iterator __a, _Iterator __b, _Iterator __c, _Compare __comp)

_OutputIterator	__move_merge (_InputIterator __first1, _InputIterator __last1, _InputIterator __first2, _InputIterator __last2, _OutputIterator __result, _Compare __comp)

void	__move_merge_adaptive (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

void	__move_merge_adaptive_backward (_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BidirectionalIterator3 __result, _Compare __comp)

_ForwardIterator	__partition (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag)

_BidirectionalIterator	__partition (_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, bidirectional_iterator_tag)

void	__reverse (_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag)

void	__reverse (_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag)

_BidirectionalIterator1	__rotate_adaptive (_BidirectionalIterator1 __first, _BidirectionalIterator1 __middle, _BidirectionalIterator1 __last, _Distance __len1, _Distance __len2, _BidirectionalIterator2 __buffer, _Distance __buffer_size)

_RandomAccessIterator	__sample (_InputIterator __first, _InputIterator __last, input_iterator_tag, _RandomAccessIterator __out, random_access_iterator_tag, _Size __n, _UniformRandomBitGenerator &&__g)

_OutputIterator	__sample (_ForwardIterator __first, _ForwardIterator __last, forward_iterator_tag, _OutputIterator __out, _Cat, _Size __n, _UniformRandomBitGenerator &&__g)

_ForwardIterator	__search_n_aux (_ForwardIterator __first, _ForwardIterator __last, _Integer __count, _UnaryPredicate __unary_pred, std::forward_iterator_tag)

_RandomAccessIter	__search_n_aux (_RandomAccessIter __first, _RandomAccessIter __last, _Integer __count, _UnaryPredicate __unary_pred, std::random_access_iterator_tag)

_ForwardIterator	__stable_partition_adaptive (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, _Distance __len, _Pointer __buffer, _Distance __buffer_size)

void	__unguarded_insertion_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

void	__unguarded_linear_insert (_RandomAccessIterator __last, _Compare __comp)

_RandomAccessIterator	__unguarded_partition (_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __pivot, _Compare __comp)

_RandomAccessIterator	__unguarded_partition_pivot (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

_OutputIterator	__unique_copy (_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __binary_pred, forward_iterator_tag, output_iterator_tag)

_OutputIterator	__unique_copy (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __binary_pred, input_iterator_tag, output_iterator_tag)

_ForwardIterator	__unique_copy (_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __binary_pred, input_iterator_tag, forward_iterator_tag)

void	_Construct (_T1 *__p, _Args &&... __args)

void	_Destroy (_Tp *__pointer)

void	_Destroy (_ForwardIterator __first, _ForwardIterator __last)

void	_Destroy (_ForwardIterator __first, _ForwardIterator __last, _Allocator &__alloc)

_ForwardIterator	_Destroy_n (_ForwardIterator __first, _Size __count)

_Tp	abs (const complex< _Tp > &)

_Tp	accumulate (_InputIterator __first, _InputIterator __last, _Tp __init)

_Tp	accumulate (_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op)

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

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

_GLIBCXX17_CONSTEXPR _Tp *	addressof (_Tp &__r) noexcept

_OutputIterator	adjacent_difference (_InputIterator __first, _InputIterator __last, _OutputIterator __result)

_OutputIterator	adjacent_difference (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op)

_ForwardIterator	adjacent_find (_ForwardIterator __first, _ForwardIterator __last)

_ForwardIterator	adjacent_find (_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred)

_GLIBCXX17_CONSTEXPR void	advance (_InputIterator &__i, _Distance __n)

void *	align (size_t __align, size_t __size, void *&__ptr, size_t &__space) noexcept

bool	all_of (_InputIterator __first, _InputIterator __last, _Predicate __pred)

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

bool	any_of (_InputIterator __first, _InputIterator __last, _Predicate __pred)

_Tp	arg (const complex< _Tp > &)

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

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

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

__gnu_cxx::__promote< _Tp >::__type	assoc_laguerre (unsigned int __n, unsigned int __m, _Tp __x)

float	assoc_laguerref (unsigned int __n, unsigned int __m, float __x)

long double	assoc_laguerrel (unsigned int __n, unsigned int __m, long double __x)

__gnu_cxx::__promote< _Tp >::__type	assoc_legendre (unsigned int __l, unsigned int __m, _Tp __x)

float	assoc_legendref (unsigned int __l, unsigned int __m, float __x)

long double	assoc_legendrel (unsigned int __l, unsigned int __m, long double __x)

future< __async_result_of< _Fn, _Args... > >	async (launch __policy, _Fn &&__fn, _Args &&... __args)

future< __async_result_of< _Fn, _Args... > >	async (_Fn &&__fn, _Args &&... __args)

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

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

back_insert_iterator< _Container >	back_inserter (_Container &__x)

_GLIBCXX17_CONSTEXPR auto	begin (_Container &__cont) -> decltype(__cont.begin())

_GLIBCXX17_CONSTEXPR auto	begin (const _Container &__cont) -> decltype(__cont.begin())

_GLIBCXX14_CONSTEXPR _Tp *	begin (_Tp(&__arr)[_Nm])

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

_Tp *	begin (valarray< _Tp > &__va)

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

__gnu_cxx::__promote_2< _Tpa, _Tpb >::__type	beta (_Tpa __a, _Tpb __b)

float	betaf (float __a, float __b)

long double	betal (long double __a, long double __b)

bool	binary_search (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val)

bool	binary_search (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val, _Compare __comp)

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

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

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

ios_base &	boolalpha (ios_base &__base)

constexpr auto	cbegin (const _Container &__cont) noexcept(noexcept(std::begin(__cont))) -> decltype(std::begin(__cont))

constexpr auto	cend (const _Container &__cont) noexcept(noexcept(std::end(__cont))) -> decltype(std::end(__cont))

__gnu_cxx::__promote< _Tp >::__type	comp_ellint_1 (_Tp __k)

float	comp_ellint_1f (float __k)

long double	comp_ellint_1l (long double __k)

__gnu_cxx::__promote< _Tp >::__type	comp_ellint_2 (_Tp __k)

float	comp_ellint_2f (float __k)

long double	comp_ellint_2l (long double __k)

__gnu_cxx::__promote_2< _Tp, _Tpn >::__type	comp_ellint_3 (_Tp __k, _Tpn __nu)

float	comp_ellint_3f (float __k, float __nu)

long double	comp_ellint_3l (long double __k, long double __nu)

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

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

_OI	copy (_II __first, _II __last, _OI __result)

_BI2	copy_backward (_BI1 __first, _BI1 __last, _BI2 __result)

exception_ptr	copy_exception (_Ex __ex) noexcept 1

_OutputIterator	copy_if (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)

_OutputIterator	copy_n (_InputIterator __first, _Size __n, _OutputIterator __result)

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

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

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

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

_GLIBCXX17_CONSTEXPR auto	crbegin (const _Container &__cont) -> decltype(std::rbegin(__cont))

_GLIBCXX17_CONSTEXPR auto	crend (const _Container &__cont) -> decltype(std::rend(__cont))

exception_ptr	current_exception () noexcept

__gnu_cxx::__promote_2< _Tpnu, _Tp >::__type	cyl_bessel_i (_Tpnu __nu, _Tp __x)

float	cyl_bessel_if (float __nu, float __x)

long double	cyl_bessel_il (long double __nu, long double __x)

__gnu_cxx::__promote_2< _Tpnu, _Tp >::__type	cyl_bessel_j (_Tpnu __nu, _Tp __x)

float	cyl_bessel_jf (float __nu, float __x)

long double	cyl_bessel_jl (long double __nu, long double __x)

__gnu_cxx::__promote_2< _Tpnu, _Tp >::__type	cyl_bessel_k (_Tpnu __nu, _Tp __x)

float	cyl_bessel_kf (float __nu, float __x)

long double	cyl_bessel_kl (long double __nu, long double __x)

__gnu_cxx::__promote_2< _Tpnu, _Tp >::__type	cyl_neumann (_Tpnu __nu, _Tp __x)

float	cyl_neumannf (float __nu, float __x)

long double	cyl_neumannl (long double __nu, long double __x)

ios_base &	dec (ios_base &__base)

ios_base &	defaultfloat (ios_base &__base)

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

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

__gnu_cxx::__promote_2< _Tp, _Tpp >::__type	ellint_1 (_Tp __k, _Tpp __phi)

float	ellint_1f (float __k, float __phi)

long double	ellint_1l (long double __k, long double __phi)

__gnu_cxx::__promote_2< _Tp, _Tpp >::__type	ellint_2 (_Tp __k, _Tpp __phi)

float	ellint_2f (float __k, float __phi)

long double	ellint_2l (long double __k, long double __phi)

__gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp >::__type	ellint_3 (_Tp __k, _Tpn __nu, _Tpp __phi)

float	ellint_3f (float __k, float __nu, float __phi)

long double	ellint_3l (long double __k, long double __nu, long double __phi)

_GLIBCXX17_CONSTEXPR auto	end (_Container &__cont) -> decltype(__cont.end())

_GLIBCXX17_CONSTEXPR auto	end (const _Container &__cont) -> decltype(__cont.end())

_GLIBCXX14_CONSTEXPR _Tp *	end (_Tp(&__arr)[_Nm])

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

_Tp *	end (valarray< _Tp > &__va)

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

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

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

bool	equal (_IIter1 __first1, _IIter1 __last1, _IIter2 __first2, _BinaryPredicate __binary_pred)

bool	equal (_II1 __first1, _II1 __last1, _II2 __first2)

bool	equal (_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)

bool	equal (_IIter1 __first1, _IIter1 __last1, _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)

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

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

_Tp	exchange (_Tp &__obj, _Up &&__new_val)

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

__gnu_cxx::__promote< _Tp >::__type	expint (_Tp __x)

float	expintf (float __x)

long double	expintl (long double __x)

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

void	fill (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__value)

_OI	fill_n (_OI __first, _Size __n, const _Tp &__value)

_InputIterator	find (_InputIterator __first, _InputIterator __last, const _Tp &__val)

_ForwardIterator1	find_end (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2)

_ForwardIterator1	find_end (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __comp)

_InputIterator	find_first_of (_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2)

_InputIterator	find_first_of (_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2, _BinaryPredicate __comp)

_InputIterator	find_if (_InputIterator __first, _InputIterator __last, _Predicate __pred)

_InputIterator	find_if_not (_InputIterator __first, _InputIterator __last, _Predicate __pred)

ios_base &	fixed (ios_base &__base)

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

_Function	for_each (_InputIterator __first, _InputIterator __last, _Function __f)

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

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

front_insert_iterator< _Container >	front_inserter (_Container &__x)

const error_category &	future_category () noexcept

void	generate (_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)

_RealType	generate_canonical (_UniformRandomNumberGenerator &__g)

_OutputIterator	generate_n (_OutputIterator __first, _Size __n, _Generator __gen)

constexpr __tuple_element_t< __i, tuple< _Elements... > > &	get (tuple< _Elements... > &__t) noexcept

constexpr const __tuple_element_t< __i, tuple< _Elements... > > &	get (const tuple< _Elements... > &__t) noexcept

constexpr __tuple_element_t< __i, tuple< _Elements... > > &&	get (tuple< _Elements... > &&__t) noexcept

constexpr _Tp &	get (tuple< _Types... > &__t) noexcept

constexpr _Tp &&	get (tuple< _Types... > &&__t) noexcept

constexpr const _Tp &	get (const tuple< _Types... > &__t) noexcept

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

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

new_handler	get_new_handler () noexcept

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

terminate_handler	get_terminate () noexcept

_Get_time< _CharT >	get_time (std::tm __tmb, const _CharT __fmt)

unexpected_handler	get_unexpected () noexcept

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

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

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

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

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

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

bool	has_facet (const locale &__loc)

__gnu_cxx::__promote< _Tp >::__type	hermite (unsigned int __n, _Tp __x)

float	hermitef (unsigned int __n, float __x)

long double	hermitel (unsigned int __n, long double __x)

ios_base &	hex (ios_base &__base)

ios_base &	hexfloat (ios_base &__base)

bool	includes (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)

bool	includes (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)

_Tp	inner_product (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init)

_Tp	inner_product (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2)

void	inplace_merge (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last)

void	inplace_merge (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp)

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

ios_base &	internal (ios_base &__base)

void	iota (_ForwardIterator __first, _ForwardIterator __last, _Tp __value)

bool	is_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)

bool	is_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

_RandomAccessIterator	is_heap_until (_RandomAccessIterator __first, _RandomAccessIterator __last)

_RandomAccessIterator	is_heap_until (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

bool	is_partitioned (_InputIterator __first, _InputIterator __last, _Predicate __pred)

bool	is_permutation (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)

bool	is_permutation (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __pred)

bool	is_permutation (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2)

bool	is_permutation (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)

bool	is_sorted (_ForwardIterator __first, _ForwardIterator __last)

bool	is_sorted (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

_ForwardIterator	is_sorted_until (_ForwardIterator __first, _ForwardIterator __last)

_ForwardIterator	is_sorted_until (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

bool	isalnum (_CharT __c, const locale &__loc)

bool	isalpha (_CharT __c, const locale &__loc)

bool	isblank (_CharT __c, const locale &__loc)

bool	iscntrl (_CharT __c, const locale &__loc)

bool	isdigit (_CharT __c, const locale &__loc)

bool	isgraph (_CharT __c, const locale &__loc)

bool	islower (_CharT __c, const locale &__loc)

bool	isprint (_CharT __c, const locale &__loc)

bool	ispunct (_CharT __c, const locale &__loc)

bool	isspace (_CharT __c, const locale &__loc)

bool	isupper (_CharT __c, const locale &__loc)

bool	isxdigit (_CharT __c, const locale &__loc)

void	iter_swap (_ForwardIterator1 __a, _ForwardIterator2 __b)

_Tp	kill_dependency (_Tp __y) noexcept

__gnu_cxx::__promote< _Tp >::__type	laguerre (unsigned int __n, _Tp __x)

float	laguerref (unsigned int __n, float __x)

long double	laguerrel (unsigned int __n, long double __x)

ios_base &	left (ios_base &__base)

__gnu_cxx::__promote< _Tp >::__type	legendre (unsigned int __l, _Tp __x)

float	legendref (unsigned int __l, float __x)

long double	legendrel (unsigned int __l, long double __x)

bool	lexicographical_compare (_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)

bool	lexicographical_compare (_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _Compare __comp)

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

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

_ForwardIterator	lower_bound (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val)

_ForwardIterator	lower_bound (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val, _Compare __comp)

error_code	make_error_code (future_errc __errc) noexcept

error_condition	make_error_condition (future_errc __errc) noexcept

exception_ptr	make_exception_ptr (_Ex __ex) noexcept

void	make_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)

void	make_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

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

_GLIBCXX17_CONSTEXPR reverse_iterator< _Iterator >	make_reverse_iterator (_Iterator __i)

shared_ptr< _Tp >	make_shared (_Args &&... __args)

_MakeUniq< _Tp >::__single_object	make_unique (_Args &&... __args)

_MakeUniq< _Tp >::__array	make_unique (size_t __num)

_MakeUniq< _Tp >::__invalid_type	make_unique (_Args &&...)=delete

_GLIBCXX14_CONSTEXPR const _Tp &	max (const _Tp &__a, const _Tp &__b)

_GLIBCXX14_CONSTEXPR const _Tp &	max (const _Tp &__a, const _Tp &__b, _Compare __comp)

_GLIBCXX14_CONSTEXPR _ForwardIterator	max_element (_ForwardIterator __first, _ForwardIterator __last)

_GLIBCXX14_CONSTEXPR _ForwardIterator	max_element (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

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

_OutputIterator	merge (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)

_OutputIterator	merge (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

_GLIBCXX14_CONSTEXPR const _Tp &	min (const _Tp &__a, const _Tp &__b)

_GLIBCXX14_CONSTEXPR const _Tp &	min (const _Tp &__a, const _Tp &__b, _Compare __comp)

_GLIBCXX14_CONSTEXPR _ForwardIterator	min_element (_ForwardIterator __first, _ForwardIterator __last)

_GLIBCXX14_CONSTEXPR _ForwardIterator	min_element (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

_GLIBCXX14_CONSTEXPR pair< const _Tp &, const _Tp &>	minmax (const _Tp &__a, const _Tp &__b)

_GLIBCXX14_CONSTEXPR pair< const _Tp &, const _Tp &>	minmax (const _Tp &__a, const _Tp &__b, _Compare __comp)

_GLIBCXX14_CONSTEXPR pair< _ForwardIterator, _ForwardIterator >	minmax_element (_ForwardIterator __first, _ForwardIterator __last)

_GLIBCXX14_CONSTEXPR pair< _ForwardIterator, _ForwardIterator >	minmax_element (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)

pair< _InputIterator1, _InputIterator2 >	mismatch (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)

pair< _InputIterator1, _InputIterator2 >	mismatch (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __binary_pred)

pair< _InputIterator1, _InputIterator2 >	mismatch (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)

pair< _InputIterator1, _InputIterator2 >	mismatch (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __binary_pred)

constexpr std::remove_reference< _Tp >::type &&	move (_Tp &&__t) noexcept

_OI	move (_II __first, _II __last, _OI __result)

_BI2	move_backward (_BI1 __first, _BI1 __last, _BI2 __result)

constexpr conditional< __move_if_noexcept_cond< _Tp >::value, const _Tp &, _Tp &&>::type	move_if_noexcept (_Tp &__x) noexcept

bool	next_permutation (_BidirectionalIterator __first, _BidirectionalIterator __last)

bool	next_permutation (_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)

ios_base &	noboolalpha (ios_base &__base)

bool	none_of (_InputIterator __first, _InputIterator __last, _Predicate __pred)

_Tp	norm (const complex< _Tp > &)

ios_base &	noshowbase (ios_base &__base)

ios_base &	noshowpoint (ios_base &__base)

ios_base &	noshowpos (ios_base &__base)

ios_base &	noskipws (ios_base &__base)

_GLIBCXX14_CONSTEXPR unary_negate< _Predicate >	not1 (const _Predicate &__pred)

_GLIBCXX14_CONSTEXPR binary_negate< _Predicate >	not2 (const _Predicate &__pred)

ios_base &	nounitbuf (ios_base &__base)

ios_base &	nouppercase (ios_base &__base)

void	nth_element (_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last)

void	nth_element (_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)

ios_base &	oct (ios_base &__base)

bool	operator!= (const istream_iterator< _Tp, _CharT, _Traits, _Dist > &__x, const istream_iterator< _Tp, _CharT, _Traits, _Dist > &__y)

bool	operator!= (const _Fwd_list_iterator< _Tp > &__x, const _Fwd_list_const_iterator< _Tp > &__y) noexcept

bool	operator!= (const stack< _Tp, _Seq > &__x, const stack< _Tp, _Seq > &__y)

bool	operator!= (const queue< _Tp, _Seq > &__x, const queue< _Tp, _Seq > &__y)

bool	operator!= (const std::linear_congruential_engine< _UIntType, __a, __c, __m > &__lhs, const std::linear_congruential_engine< _UIntType, __a, __c, __m > &__rhs)

constexpr bool	operator!= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)

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)

bool	operator!= (const function< _Res(_Args...)> &__f, nullptr_t) noexcept

bool	operator!= (nullptr_t, const function< _Res(_Args...)> &__f) noexcept

bool	operator!= (const std::subtract_with_carry_engine< _UIntType, __w, __s, __r > &__lhs, const std::subtract_with_carry_engine< _UIntType, __w, __s, __r > &__rhs)

bool	operator!= (const multiset< _Key, _Compare, _Alloc > &__x, const multiset< _Key, _Compare, _Alloc > &__y)

bool	operator!= (const set< _Key, _Compare, _Alloc > &__x, const set< _Key, _Compare, _Alloc > &__y)

bool	operator!= (const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)

bool	operator!= (const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator!= (const std::discard_block_engine< _RandomNumberEngine, __p, __r > &__lhs, const std::discard_block_engine< _RandomNumberEngine, __p, __r > &__rhs)

bool	operator!= (const multimap< _Key, _Tp, _Compare, _Alloc > &__x, const multimap< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator!= (const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)

bool	operator!= (typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator!= (const std::independent_bits_engine< _RandomNumberEngine, __w, _UIntType > &__lhs, const std::independent_bits_engine< _RandomNumberEngine, __w, _UIntType > &__rhs)

bool	operator!= (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)

bool	operator!= (typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator!= (const forward_list< _Tp, _Alloc > &__lx, const forward_list< _Tp, _Alloc > &__ly)

bool	operator!= (const map< _Key, _Tp, _Compare, _Alloc > &__x, const map< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator!= (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)

bool	operator!= (const std::shuffle_order_engine< _RandomNumberEngine, __k > &__lhs, const std::shuffle_order_engine< _RandomNumberEngine, __k > &__rhs)

bool	operator!= (const vector< _Tp, _Alloc > &__x, const vector< _Tp, _Alloc > &__y)

bool	operator!= (const std::uniform_int_distribution< _IntType > &__d1, const std::uniform_int_distribution< _IntType > &__d2)

bool	operator!= (const std::uniform_real_distribution< _IntType > &__d1, const std::uniform_real_distribution< _IntType > &__d2)

bool	operator!= (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)

bool	operator!= (const match_results< _Bi_iter, _Alloc > &__m1, const match_results< _Bi_iter, _Alloc > &__m2)

bool	operator!= (const std::normal_distribution< _RealType > &__d1, const std::normal_distribution< _RealType > &__d2)

bool	operator!= (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)

bool	operator!= (const std::lognormal_distribution< _RealType > &__d1, const std::lognormal_distribution< _RealType > &__d2)

bool	operator!= (const std::gamma_distribution< _RealType > &__d1, const std::gamma_distribution< _RealType > &__d2)

bool	operator!= (const std::chi_squared_distribution< _RealType > &__d1, const std::chi_squared_distribution< _RealType > &__d2)

bool	operator!= (const std::cauchy_distribution< _RealType > &__d1, const std::cauchy_distribution< _RealType > &__d2)

bool	operator!= (const std::fisher_f_distribution< _RealType > &__d1, const std::fisher_f_distribution< _RealType > &__d2)

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)

bool	operator!= (const std::binomial_distribution< _IntType > &__d1, const std::binomial_distribution< _IntType > &__d2)

bool	operator!= (const std::geometric_distribution< _IntType > &__d1, const std::geometric_distribution< _IntType > &__d2)

bool	operator!= (const std::negative_binomial_distribution< _IntType > &__d1, const std::negative_binomial_distribution< _IntType > &__d2)

bool	operator!= (const std::poisson_distribution< _IntType > &__d1, const std::poisson_distribution< _IntType > &__d2)

bool	operator!= (const std::exponential_distribution< _RealType > &__d1, const std::exponential_distribution< _RealType > &__d2)

bool	operator!= (const std::weibull_distribution< _RealType > &__d1, const std::weibull_distribution< _RealType > &__d2)

bool	operator!= (const std::extreme_value_distribution< _RealType > &__d1, const std::extreme_value_distribution< _RealType > &__d2)

bool	operator!= (const std::discrete_distribution< _IntType > &__d1, const std::discrete_distribution< _IntType > &__d2)

bool	operator!= (const std::piecewise_constant_distribution< _RealType > &__d1, const std::piecewise_constant_distribution< _RealType > &__d2)

bool	operator!= (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs) noexcept

bool	operator!= (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

bool	operator!= (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

bool	operator!= (const std::piecewise_linear_distribution< _RealType > &__d1, const std::piecewise_linear_distribution< _RealType > &__d2)

complex< _Tp >	operator+ (const complex< _Tp > &__x)

basic_string< _CharT, _Traits, _Alloc >	operator+ (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

basic_string< _CharT, _Traits, _Alloc >	operator+ (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

basic_string< _CharT, _Traits, _Alloc >	operator+ (_CharT __lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

basic_string< _CharT, _Traits, _Alloc >	operator+ (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

basic_string< _CharT, _Traits, _Alloc >	operator+ (const basic_string< _CharT, _Traits, _Alloc > &__lhs, _CharT __rhs)

complex< _Tp >	operator- (const complex< _Tp > &__x)

bool	operator< (const stack< _Tp, _Seq > &__x, const stack< _Tp, _Seq > &__y)

bool	operator< (const queue< _Tp, _Seq > &__x, const queue< _Tp, _Seq > &__y)

constexpr bool	operator< (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)

bool	operator< (const multiset< _Key, _Compare, _Alloc > &__x, const multiset< _Key, _Compare, _Alloc > &__y)

bool	operator< (const set< _Key, _Compare, _Alloc > &__x, const set< _Key, _Compare, _Alloc > &__y)

bool	operator< (const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)

bool	operator< (const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator< (const multimap< _Key, _Tp, _Compare, _Alloc > &__x, const multimap< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator< (const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)

bool	operator< (typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator< (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)

bool	operator< (typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator< (const forward_list< _Tp, _Alloc > &__lx, const forward_list< _Tp, _Alloc > &__ly)

bool	operator< (const map< _Key, _Tp, _Compare, _Alloc > &__x, const map< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator< (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)

bool	operator< (const vector< _Tp, _Alloc > &__x, const vector< _Tp, _Alloc > &__y)

bool	operator< (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)

bool	operator< (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)

bool	operator< (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs) noexcept

bool	operator< (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

bool	operator< (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

std::basic_ostream< _Ch, _Tr > &	operator<< (std::basic_ostream< _Ch, _Tr > &__os, const __shared_ptr< _Tp, _Lp > &__p)

basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, const complex< _Tp > &__x)

enable_if< __and_< __not_< is_lvalue_reference< _Ostream > >, __is_convertible_to_basic_ostream< _Ostream >, __is_insertable< __rvalue_ostream_type< _Ostream >, const _Tp &> >::value, __rvalue_ostream_type< _Ostream > >::type	operator<< (_Ostream &&__os, const _Tp &__x)

std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::independent_bits_engine< _RandomNumberEngine, __w, _UIntType > &__x)

basic_ostream< _Ch_type, _Ch_traits > &	operator<< (basic_ostream< _Ch_type, _Ch_traits > &__os, const sub_match< _Bi_iter > &__m)

std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &, const std::uniform_int_distribution< _IntType > &)

std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &, const std::uniform_real_distribution< _RealType > &)

basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, const __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base > &__str)

std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::cauchy_distribution< _RealType > &__x)

std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::bernoulli_distribution &__x)

std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::geometric_distribution< _IntType > &__x)

std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::exponential_distribution< _RealType > &__x)

std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::weibull_distribution< _RealType > &__x)

std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const std::extreme_value_distribution< _RealType > &__x)

basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__os, const basic_string< _CharT, _Traits, _Alloc > &__str)

bool	operator<= (const stack< _Tp, _Seq > &__x, const stack< _Tp, _Seq > &__y)

bool	operator<= (const queue< _Tp, _Seq > &__x, const queue< _Tp, _Seq > &__y)

constexpr bool	operator<= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)

bool	operator<= (const multiset< _Key, _Compare, _Alloc > &__x, const multiset< _Key, _Compare, _Alloc > &__y)

bool	operator<= (const set< _Key, _Compare, _Alloc > &__x, const set< _Key, _Compare, _Alloc > &__y)

bool	operator<= (const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)

bool	operator<= (const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator<= (const multimap< _Key, _Tp, _Compare, _Alloc > &__x, const multimap< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator<= (const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)

bool	operator<= (typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator<= (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)

bool	operator<= (typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator<= (const map< _Key, _Tp, _Compare, _Alloc > &__x, const map< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator<= (const forward_list< _Tp, _Alloc > &__lx, const forward_list< _Tp, _Alloc > &__ly)

bool	operator<= (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)

bool	operator<= (const vector< _Tp, _Alloc > &__x, const vector< _Tp, _Alloc > &__y)

bool	operator<= (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)

bool	operator<= (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)

bool	operator<= (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs) noexcept

bool	operator<= (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

bool	operator<= (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

bool	operator== (const istream_iterator< _Tp, _CharT, _Traits, _Dist > &__x, const istream_iterator< _Tp, _CharT, _Traits, _Dist > &__y)

bool	operator== (const fpos< _StateT > &__lhs, const fpos< _StateT > &__rhs)

bool	operator== (const _Fwd_list_iterator< _Tp > &__x, const _Fwd_list_const_iterator< _Tp > &__y) noexcept

bool	operator== (const stack< _Tp, _Seq > &__x, const stack< _Tp, _Seq > &__y)

_GLIBCXX17_CONSTEXPR bool	operator== (const reverse_iterator< _Iterator > &__x, const reverse_iterator< _Iterator > &__y)

bool	operator== (const queue< _Tp, _Seq > &__x, const queue< _Tp, _Seq > &__y)

constexpr bool	operator== (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)

bool	operator== (const function< _Res(_Args...)> &__f, nullptr_t) noexcept

bool	operator== (nullptr_t, const function< _Res(_Args...)> &__f) noexcept

bool	operator== (const multiset< _Key, _Compare, _Alloc > &__x, const multiset< _Key, _Compare, _Alloc > &__y)

bool	operator== (const set< _Key, _Compare, _Alloc > &__x, const set< _Key, _Compare, _Alloc > &__y)

bool	operator== (const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)

bool	operator== (const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator== (const multimap< _Key, _Tp, _Compare, _Alloc > &__x, const multimap< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator== (const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)

bool	operator== (typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator== (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)

bool	operator== (typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator== (const forward_list< _Tp, _Alloc > &__lx, const forward_list< _Tp, _Alloc > &__ly)

bool	operator== (const map< _Key, _Tp, _Compare, _Alloc > &__x, const map< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator== (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)

bool	operator== (const vector< _Tp, _Alloc > &__x, const vector< _Tp, _Alloc > &__y)

_GLIBCXX_END_NAMESPACE_CXX11 bool	operator== (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)

bool	operator== (const match_results< _Bi_iter, _Alloc > &__m1, const match_results< _Bi_iter, _Alloc > &__m2)

bool	operator== (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)

bool	operator== (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs) noexcept

bool	operator== (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

bool	operator== (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

bool	operator> (const stack< _Tp, _Seq > &__x, const stack< _Tp, _Seq > &__y)

bool	operator> (const queue< _Tp, _Seq > &__x, const queue< _Tp, _Seq > &__y)

constexpr bool	operator> (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)

bool	operator> (const multiset< _Key, _Compare, _Alloc > &__x, const multiset< _Key, _Compare, _Alloc > &__y)

bool	operator> (const set< _Key, _Compare, _Alloc > &__x, const set< _Key, _Compare, _Alloc > &__y)

bool	operator> (const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)

bool	operator> (const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator> (const multimap< _Key, _Tp, _Compare, _Alloc > &__x, const multimap< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator> (const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)

bool	operator> (typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator> (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)

bool	operator> (typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator> (const forward_list< _Tp, _Alloc > &__lx, const forward_list< _Tp, _Alloc > &__ly)

bool	operator> (const map< _Key, _Tp, _Compare, _Alloc > &__x, const map< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator> (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)

bool	operator> (const vector< _Tp, _Alloc > &__x, const vector< _Tp, _Alloc > &__y)

bool	operator> (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)

bool	operator> (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)

bool	operator> (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs) noexcept

bool	operator> (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

bool	operator> (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

bool	operator>= (const stack< _Tp, _Seq > &__x, const stack< _Tp, _Seq > &__y)

bool	operator>= (const queue< _Tp, _Seq > &__x, const queue< _Tp, _Seq > &__y)

constexpr bool	operator>= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)

bool	operator>= (const multiset< _Key, _Compare, _Alloc > &__x, const multiset< _Key, _Compare, _Alloc > &__y)

bool	operator>= (const set< _Key, _Compare, _Alloc > &__x, const set< _Key, _Compare, _Alloc > &__y)

bool	operator>= (const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)

bool	operator>= (const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator>= (const multimap< _Key, _Tp, _Compare, _Alloc > &__x, const multimap< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator>= (const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)

bool	operator>= (typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator>= (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)

bool	operator>= (typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)

bool	operator>= (const forward_list< _Tp, _Alloc > &__lx, const forward_list< _Tp, _Alloc > &__ly)

bool	operator>= (const map< _Key, _Tp, _Compare, _Alloc > &__x, const map< _Key, _Tp, _Compare, _Alloc > &__y)

bool	operator>= (const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)

bool	operator>= (const vector< _Tp, _Alloc > &__x, const vector< _Tp, _Alloc > &__y)

bool	operator>= (const list< _Tp, _Alloc > &__x, const list< _Tp, _Alloc > &__y)

bool	operator>= (const deque< _Tp, _Alloc > &__x, const deque< _Tp, _Alloc > &__y)

bool	operator>= (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs) noexcept

bool	operator>= (const basic_string< _CharT, _Traits, _Alloc > &__lhs, const _CharT *__rhs)

bool	operator>= (const _CharT *__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)

basic_istream< _CharT, _Traits > &	operator>> (basic_istream< _CharT, _Traits > &__is, complex< _Tp > &__x)

enable_if< __and_< __not_< is_lvalue_reference< _Istream > >, __is_convertible_to_basic_istream< _Istream >, __is_extractable< __rvalue_istream_type< _Istream >, _Tp &&> >::value, __rvalue_istream_type< _Istream > >::type	operator>> (_Istream &&__is, _Tp &&__x)

std::basic_istream< _CharT, _Traits > &	operator>> (std::basic_istream< _CharT, _Traits > &, std::uniform_int_distribution< _IntType > &)

std::basic_istream< _CharT, _Traits > &	operator>> (std::basic_istream< _CharT, _Traits > &, std::uniform_real_distribution< _RealType > &)

basic_istream< _CharT, _Traits > &	operator>> (basic_istream< _CharT, _Traits > &__is, __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base > &__str)

std::basic_istream< _CharT, _Traits > &	operator>> (std::basic_istream< _CharT, _Traits > &__is, std::cauchy_distribution< _RealType > &__x)

std::basic_istream< _CharT, _Traits > &	operator>> (std::basic_istream< _CharT, _Traits > &__is, std::bernoulli_distribution &__x)

std::basic_istream< _CharT, _Traits > &	operator>> (std::basic_istream< _CharT, _Traits > &__is, std::geometric_distribution< _IntType > &__x)

std::basic_istream< _CharT, _Traits > &	operator>> (std::basic_istream< _CharT, _Traits > &__is, std::exponential_distribution< _RealType > &__x)

std::basic_istream< _CharT, _Traits > &	operator>> (std::basic_istream< _CharT, _Traits > &__is, std::weibull_distribution< _RealType > &__x)

std::basic_istream< _CharT, _Traits > &	operator>> (std::basic_istream< _CharT, _Traits > &__is, std::extreme_value_distribution< _RealType > &__x)

basic_istream< _CharT, _Traits > &	operator>> (basic_istream< _CharT, _Traits > &__is, basic_string< _CharT, _Traits, _Alloc > &__str)

void	partial_sort (_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)

void	partial_sort (_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp)

_RandomAccessIterator	partial_sort_copy (_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last)

_RandomAccessIterator	partial_sort_copy (_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)

_OutputIterator	partial_sum (_InputIterator __first, _InputIterator __last, _OutputIterator __result)

_OutputIterator	partial_sum (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op)

_ForwardIterator	partition (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)

pair< _OutputIterator1, _OutputIterator2 >	partition_copy (_InputIterator __first, _InputIterator __last, _OutputIterator1 __out_true, _OutputIterator2 __out_false, _Predicate __pred)

_ForwardIterator	partition_point (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)

complex< _Tp >	polar (const _Tp &, const _Tp &=0)

void	pop_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)

void	pop_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

complex< _Tp >	pow (const complex< _Tp > &, int)

complex< _Tp >	pow (const complex< _Tp > &, const _Tp &)

complex< _Tp >	pow (const complex< _Tp > &, const complex< _Tp > &)

complex< _Tp >	pow (const _Tp &, const complex< _Tp > &)

bool	prev_permutation (_BidirectionalIterator __first, _BidirectionalIterator __last)

bool	prev_permutation (_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)

pointer_to_unary_function< _Arg, _Result >	ptr_fun (_Result(*__x)(_Arg))

pointer_to_binary_function< _Arg1, _Arg2, _Result >	ptr_fun (_Result(*__x)(_Arg1, _Arg2))

void	push_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)

void	push_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

_Put_money< _MoneyT >	put_money (const _MoneyT &__mon, bool __intl=false)

_Put_time< _CharT >	put_time (const std::tm __tmb, const _CharT __fmt)

auto	quoted (const _CharT *__string, _CharT __delim=_CharT('"'), _CharT __escape = _CharT('\)

void	random_shuffle (_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomNumberGenerator &&__rand)

_GLIBCXX17_CONSTEXPR auto	rbegin (_Container &__cont) -> decltype(__cont.rbegin())

_GLIBCXX17_CONSTEXPR auto	rbegin (const _Container &__cont) -> decltype(__cont.rbegin())

_GLIBCXX17_CONSTEXPR reverse_iterator< _Tp *>	rbegin (_Tp(&__arr)[_Nm])

_GLIBCXX17_CONSTEXPR reverse_iterator< const _Tp *>	rbegin (initializer_list< _Tp > __il)

_ForwardIterator	remove (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__value)

_OutputIterator	remove_copy (_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp &__value)

_OutputIterator	remove_copy_if (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)

_ForwardIterator	remove_if (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)

_GLIBCXX17_CONSTEXPR auto	rend (_Container &__cont) -> decltype(__cont.rend())

_GLIBCXX17_CONSTEXPR auto	rend (const _Container &__cont) -> decltype(__cont.rend())

_GLIBCXX17_CONSTEXPR reverse_iterator< _Tp *>	rend (_Tp(&__arr)[_Nm])

_GLIBCXX17_CONSTEXPR reverse_iterator< const _Tp *>	rend (initializer_list< _Tp > __il)

void	replace (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__old_value, const _Tp &__new_value)

_OutputIterator	replace_copy (_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp &__old_value, const _Tp &__new_value)

_OutputIterator	replace_copy_if (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred, const _Tp &__new_value)

void	replace_if (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp &__new_value)

_Resetiosflags	resetiosflags (ios_base::fmtflags __mask)

void	rethrow_exception (exception_ptr) __attribute__((__noreturn__))

void	rethrow_if_nested (const _Ex &__ex)

void	return_temporary_buffer (_Tp *__p)

void	reverse (_BidirectionalIterator __first, _BidirectionalIterator __last)

_OutputIterator	reverse_copy (_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)

__gnu_cxx::__promote< _Tp >::__type	riemann_zeta (_Tp __s)

float	riemann_zetaf (float __s)

long double	riemann_zetal (long double __s)

ios_base &	right (ios_base &__base)

_OutputIterator	rotate_copy (_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result)

ios_base &	scientific (ios_base &__base)

_ForwardIterator1	search (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2)

_ForwardIterator1	search (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __predicate)

_ForwardIterator	search_n (_ForwardIterator __first, _ForwardIterator __last, _Integer __count, const _Tp &__val)

_ForwardIterator	search_n (_ForwardIterator __first, _ForwardIterator __last, _Integer __count, const _Tp &__val, _BinaryPredicate __binary_pred)

_OutputIterator	set_difference (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)

_OutputIterator	set_difference (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

_OutputIterator	set_intersection (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)

_OutputIterator	set_intersection (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

new_handler	set_new_handler (new_handler)

_OutputIterator	set_symmetric_difference (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)

_OutputIterator	set_symmetric_difference (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

terminate_handler	set_terminate (terminate_handler) noexcept

unexpected_handler	set_unexpected (unexpected_handler) noexcept

_OutputIterator	set_union (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)

_OutputIterator	set_union (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)

_Setbase	setbase (int __base)

_Setfill< _CharT >	setfill (_CharT __c)

_Setiosflags	setiosflags (ios_base::fmtflags __mask)

_Setprecision	setprecision (int __n)

_Setw	setw (int __n)

ios_base &	showbase (ios_base &__base)

ios_base &	showpoint (ios_base &__base)

ios_base &	showpos (ios_base &__base)

void	shuffle (_RandomAccessIterator __first, _RandomAccessIterator __last, _UniformRandomNumberGenerator &&__g)

complex< _Tp >	sin (const complex< _Tp > &)

complex< _Tp >	sinh (const complex< _Tp > &)

ios_base &	skipws (ios_base &__base)

void	sort (_RandomAccessIterator __first, _RandomAccessIterator __last)

void	sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

void	sort_heap (_RandomAccessIterator __first, _RandomAccessIterator __last)

void	sort_heap (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

__gnu_cxx::__promote< _Tp >::__type	sph_bessel (unsigned int __n, _Tp __x)

float	sph_besself (unsigned int __n, float __x)

long double	sph_bessell (unsigned int __n, long double __x)

__gnu_cxx::__promote< _Tp >::__type	sph_legendre (unsigned int __l, unsigned int __m, _Tp __theta)

float	sph_legendref (unsigned int __l, unsigned int __m, float __theta)

long double	sph_legendrel (unsigned int __l, unsigned int __m, long double __theta)

__gnu_cxx::__promote< _Tp >::__type	sph_neumann (unsigned int __n, _Tp __x)

float	sph_neumannf (unsigned int __n, float __x)

long double	sph_neumannl (unsigned int __n, long double __x)

complex< _Tp >	sqrt (const complex< _Tp > &)

_ForwardIterator	stable_partition (_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)

void	stable_sort (_RandomAccessIterator __first, _RandomAccessIterator __last)

void	stable_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)

__shared_ptr< _Tp, _Lp >	static_pointer_cast (const __shared_ptr< _Tp1, _Lp > &__r) noexcept

enable_if< __and_< __not_< __is_tuple_like< _Tp > >, is_move_constructible< _Tp >, is_move_assignable< _Tp > >::value >::type	swap (_Tp &__a, _Tp &__b) noexcept(__and_< is_nothrow_move_constructible< _Tp >, is_nothrow_move_assignable< _Tp >>::value)

enable_if< __is_swappable< _Tp >::value >::type	swap (_Tp(&__a)[_Nm], _Tp(&__b)[_Nm]) noexcept(__is_nothrow_swappable< _Tp >::value)

void	swap (unique_lock< _Mutex > &__x, unique_lock< _Mutex > &__y) noexcept

enable_if< __and_< __is_swappable< _T1 >, __is_swappable< _T2 > >::value >::type	swap (pair< _T1, _T2 > &__x, pair< _T1, _T2 > &__y) noexcept(noexcept(__x.swap(__y)))

void	swap (basic_stringbuf< _CharT, _Traits, _Allocator > &__x, basic_stringbuf< _CharT, _Traits, _Allocator > &__y)

void	swap (function< _Res(_Args...)> &__x, function< _Res(_Args...)> &__y) noexcept

void	swap (basic_istringstream< _CharT, _Traits, _Allocator > &__x, basic_istringstream< _CharT, _Traits, _Allocator > &__y)

void	swap (basic_regex< _Ch_type, _Rx_traits > &__lhs, basic_regex< _Ch_type, _Rx_traits > &__rhs)

void	swap (basic_ostringstream< _CharT, _Traits, _Allocator > &__x, basic_ostringstream< _CharT, _Traits, _Allocator > &__y)

void	swap (basic_stringstream< _CharT, _Traits, _Allocator > &__x, basic_stringstream< _CharT, _Traits, _Allocator > &__y)

void	swap (multiset< _Key, _Compare, _Alloc > &__x, multiset< _Key, _Compare, _Alloc > &__y) noexcept(/conditional /)

void	swap (set< _Key, _Compare, _Alloc > &__x, set< _Key, _Compare, _Alloc > &__y) noexcept(/conditional /)

void	swap (basic_filebuf< _CharT, _Traits > &__x, basic_filebuf< _CharT, _Traits > &__y)

void	swap (basic_ifstream< _CharT, _Traits > &__x, basic_ifstream< _CharT, _Traits > &__y)

void	swap (basic_ofstream< _CharT, _Traits > &__x, basic_ofstream< _CharT, _Traits > &__y)

void	swap (basic_fstream< _CharT, _Traits > &__x, basic_fstream< _CharT, _Traits > &__y)

void	swap (multimap< _Key, _Tp, _Compare, _Alloc > &__x, multimap< _Key, _Tp, _Compare, _Alloc > &__y) noexcept(/conditional /)

void	swap (forward_list< _Tp, _Alloc > &__lx, forward_list< _Tp, _Alloc > &__ly) noexcept(noexcept(__lx.swap(__ly)))

void	swap (map< _Key, _Tp, _Compare, _Alloc > &__x, map< _Key, _Tp, _Compare, _Alloc > &__y) noexcept(/conditional /)

void	swap (packaged_task< _Res(_ArgTypes...)> &__x, packaged_task< _Res(_ArgTypes...)> &__y) noexcept

enable_if< __and_< __is_swappable< _Elements >... >::value >::type	swap (tuple< _Elements... > &__x, tuple< _Elements... > &__y) noexcept(noexcept(__x.swap(__y)))

void	swap (vector< _Tp, _Alloc > &__x, vector< _Tp, _Alloc > &__y) noexcept(/conditional /)

void	swap (list< _Tp, _Alloc > &__x, list< _Tp, _Alloc > &__y) noexcept(/conditional /)

void	swap (match_results< _Bi_iter, _Alloc > &__lhs, match_results< _Bi_iter, _Alloc > &__rhs)

void	swap (deque< _Tp, _Alloc > &__x, deque< _Tp, _Alloc > &__y) noexcept(/conditional /)

void	swap (basic_string< _CharT, _Traits, _Alloc > &__lhs, basic_string< _CharT, _Traits, _Alloc > &__rhs) noexcept(/conditional /)

_ForwardIterator2	swap_ranges (_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)

complex< _Tp >	tan (const complex< _Tp > &)

complex< _Tp >	tanh (const complex< _Tp > &)

void	terminate () noexcept __attribute__((__noreturn__))

void	throw_with_nested (_Tp &&__t)

constexpr tuple< _Elements &... >	tie (_Elements &... __args) noexcept

_CharT	tolower (_CharT __c, const locale &__loc)

_CharT	toupper (_CharT __c, const locale &__loc)

_OutputIterator	transform (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __unary_op)

_OutputIterator	transform (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _OutputIterator __result, _BinaryOperation __binary_op)

constexpr auto	tuple_cat (_Tpls &&... __tpls) -> typename __tuple_cat_result< _Tpls... >::__type

bool	uncaught_exception () noexcept __attribute__((__pure__))

int	uncaught_exceptions () noexcept __attribute__((__pure__))

void	unexpected () __attribute__((__noreturn__))

_ForwardIterator	uninitialized_copy (_InputIterator __first, _InputIterator __last, _ForwardIterator __result)

_ForwardIterator	uninitialized_copy_n (_InputIterator __first, _Size __n, _ForwardIterator __result)

void	uninitialized_fill (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__x)

_ForwardIterator	uninitialized_fill_n (_ForwardIterator __first, _Size __n, const _Tp &__x)

_ForwardIterator	unique (_ForwardIterator __first, _ForwardIterator __last)

_ForwardIterator	unique (_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __binary_pred)

_OutputIterator	unique_copy (_InputIterator __first, _InputIterator __last, _OutputIterator __result)

_OutputIterator	unique_copy (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __binary_pred)

ios_base &	unitbuf (ios_base &__base)

_ForwardIterator	upper_bound (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val)

_ForwardIterator	upper_bound (_ForwardIterator __first, _ForwardIterator __last, const _Tp &__val, _Compare __comp)

ios_base &	uppercase (ios_base &__base)

const _Facet &	use_facet (const locale &__loc)

basic_istream< _CharT, _Traits > &	ws (basic_istream< _CharT, _Traits > &__is)

bitset< _Nb >	operator& (const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept

bitset< _Nb >	operator\| (const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept

bitset< _Nb >	operator^ (const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept

std::basic_istream< _CharT, _Traits > &	operator>> (std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)

std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)

complex< _Tp >	operator+ (const complex< _Tp > &__x, const complex< _Tp > &__y)

complex< _Tp >	operator+ (const complex< _Tp > &__x, const _Tp &__y)

complex< _Tp >	operator+ (const _Tp &__x, const complex< _Tp > &__y)

complex< _Tp >	operator- (const complex< _Tp > &__x, const complex< _Tp > &__y)

complex< _Tp >	operator- (const complex< _Tp > &__x, const _Tp &__y)

complex< _Tp >	operator- (const _Tp &__x, const complex< _Tp > &__y)

complex< _Tp >	operator* (const complex< _Tp > &__x, const complex< _Tp > &__y)

complex< _Tp >	operator* (const complex< _Tp > &__x, const _Tp &__y)

complex< _Tp >	operator* (const _Tp &__x, const complex< _Tp > &__y)

complex< _Tp >	operator/ (const complex< _Tp > &__x, const complex< _Tp > &__y)

complex< _Tp >	operator/ (const complex< _Tp > &__x, const _Tp &__y)

complex< _Tp >	operator/ (const _Tp &__x, const complex< _Tp > &__y)

constexpr bool	operator== (const complex< _Tp > &__x, const complex< _Tp > &__y)

constexpr bool	operator== (const complex< _Tp > &__x, const _Tp &__y)

constexpr bool	operator== (const _Tp &__x, const complex< _Tp > &__y)

constexpr bool	operator!= (const complex< _Tp > &__x, const complex< _Tp > &__y)

constexpr bool	operator!= (const complex< _Tp > &__x, const _Tp &__y)

constexpr bool	operator!= (const _Tp &__x, const complex< _Tp > &__y)

basic_istream< _CharT, _Traits > &	operator>> (basic_istream< _CharT, _Traits > &__in, _CharT &__c)

basic_istream< char, _Traits > &	operator>> (basic_istream< char, _Traits > &__in, unsigned char &__c)

basic_istream< char, _Traits > &	operator>> (basic_istream< char, _Traits > &__in, signed char &__c)

basic_istream< _CharT, _Traits > &	operator>> (basic_istream< _CharT, _Traits > &__in, _CharT *__s)

basic_istream< char > &	operator>> (basic_istream< char > &__in, char *__s)

basic_istream< char, _Traits > &	operator>> (basic_istream< char, _Traits > &__in, unsigned char *__s)

basic_istream< char, _Traits > &	operator>> (basic_istream< char, _Traits > &__in, signed char *__s)

basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__out, _CharT __c)

basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__out, char __c)

basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &__out, char __c)

basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &__out, signed char __c)

basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &__out, unsigned char __c)

basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__out, const _CharT *__s)

basic_ostream< _CharT, _Traits > &	operator<< (basic_ostream< _CharT, _Traits > &__out, const char *__s)

basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &__out, const char *__s)

basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &__out, const signed char *__s)

basic_ostream< char, _Traits > &	operator<< (basic_ostream< char, _Traits > &__out, const unsigned char *__s)

reference_wrapper< _Tp >	ref (_Tp &__t) noexcept

reference_wrapper< const _Tp >	cref (const _Tp &__t) noexcept

void	ref (const _Tp &&)=delete

void	cref (const _Tp &&)=delete

reference_wrapper< _Tp >	ref (reference_wrapper< _Tp > __t) noexcept

reference_wrapper< const _Tp >	cref (reference_wrapper< _Tp > __t) noexcept

bool	regex_match (_Bi_iter __s, _Bi_iter __e, match_results< _Bi_iter, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)

bool	regex_match (_Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)

bool	regex_match (const _Ch_type __s, match_results< const _Ch_type , _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __f=regex_constants::match_default)

bool	regex_match (const basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &__s, match_results< typename basic_string< _Ch_type, _Ch_traits, _Ch_alloc >::const_iterator, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)

bool	regex_match (const basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &&, match_results< typename basic_string< _Ch_type, _Ch_traits, _Ch_alloc >::const_iterator, _Alloc > &, const basic_regex< _Ch_type, _Rx_traits > &, regex_constants::match_flag_type=regex_constants::match_default)=delete

bool	regex_match (const _Ch_type *__s, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __f=regex_constants::match_default)

bool	regex_match (const basic_string< _Ch_type, _Ch_traits, _Str_allocator > &__s, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)

bool	regex_search (_Bi_iter __s, _Bi_iter __e, match_results< _Bi_iter, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)

bool	regex_search (_Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)

bool	regex_search (const _Ch_type __s, match_results< const _Ch_type , _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__e, regex_constants::match_flag_type __f=regex_constants::match_default)

bool	regex_search (const _Ch_type *__s, const basic_regex< _Ch_type, _Rx_traits > &__e, regex_constants::match_flag_type __f=regex_constants::match_default)

bool	regex_search (const basic_string< _Ch_type, _Ch_traits, _String_allocator > &__s, const basic_regex< _Ch_type, _Rx_traits > &__e, regex_constants::match_flag_type __flags=regex_constants::match_default)

bool	regex_search (const basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &__s, match_results< typename basic_string< _Ch_type, _Ch_traits, _Ch_alloc >::const_iterator, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__e, regex_constants::match_flag_type __f=regex_constants::match_default)

bool	regex_search (const basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &&, match_results< typename basic_string< _Ch_type, _Ch_traits, _Ch_alloc >::const_iterator, _Alloc > &, const basic_regex< _Ch_type, _Rx_traits > &, regex_constants::match_flag_type=regex_constants::match_default)=delete

_Out_iter	regex_replace (_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__e, const basic_string< _Ch_type, _St, _Sa > &__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)

_Out_iter	regex_replace (_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__e, const _Ch_type *__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)

basic_string< _Ch_type, _St, _Sa >	regex_replace (const basic_string< _Ch_type, _St, _Sa > &__s, const basic_regex< _Ch_type, _Rx_traits > &__e, const basic_string< _Ch_type, _Fst, _Fsa > &__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)

basic_string< _Ch_type, _St, _Sa >	regex_replace (const basic_string< _Ch_type, _St, _Sa > &__s, const basic_regex< _Ch_type, _Rx_traits > &__e, const _Ch_type *__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)

basic_string< _Ch_type >	regex_replace (const _Ch_type *__s, const basic_regex< _Ch_type, _Rx_traits > &__e, const basic_string< _Ch_type, _St, _Sa > &__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)

basic_string< _Ch_type >	regex_replace (const _Ch_type __s, const basic_regex< _Ch_type, _Rx_traits > &__e, const _Ch_type __fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)

bool	atomic_is_lock_free (const __shared_ptr< _Tp, _Lp > *__p)

bool	atomic_is_lock_free (const shared_ptr< _Tp > *__p)

shared_ptr< _Tp >	atomic_load_explicit (const shared_ptr< _Tp > *__p, memory_order)

shared_ptr< _Tp >	atomic_load (const shared_ptr< _Tp > *__p)

__shared_ptr< _Tp, _Lp >	atomic_load_explicit (const __shared_ptr< _Tp, _Lp > *__p, memory_order)

__shared_ptr< _Tp, _Lp >	atomic_load (const __shared_ptr< _Tp, _Lp > *__p)

void	atomic_store_explicit (shared_ptr< _Tp > *__p, shared_ptr< _Tp > __r, memory_order)

void	atomic_store (shared_ptr< _Tp > *__p, shared_ptr< _Tp > __r)

void	atomic_store_explicit (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > __r, memory_order)

void	atomic_store (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > __r)

shared_ptr< _Tp >	atomic_exchange_explicit (shared_ptr< _Tp > *__p, shared_ptr< _Tp > __r, memory_order)

shared_ptr< _Tp >	atomic_exchange (shared_ptr< _Tp > *__p, shared_ptr< _Tp > __r)

__shared_ptr< _Tp, _Lp >	atomic_exchange_explicit (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > __r, memory_order)

__shared_ptr< _Tp, _Lp >	atomic_exchange (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > __r)

bool	atomic_compare_exchange_strong_explicit (shared_ptr< _Tp > __p, shared_ptr< _Tp > __v, shared_ptr< _Tp > __w, memory_order, memory_order)

bool	atomic_compare_exchange_strong (shared_ptr< _Tp > __p, shared_ptr< _Tp > __v, shared_ptr< _Tp > __w)

bool	atomic_compare_exchange_weak_explicit (shared_ptr< _Tp > __p, shared_ptr< _Tp > __v, shared_ptr< _Tp > __w, memory_order __success, memory_order __failure)

bool	atomic_compare_exchange_weak (shared_ptr< _Tp > __p, shared_ptr< _Tp > __v, shared_ptr< _Tp > __w)

bool	atomic_compare_exchange_strong_explicit (__shared_ptr< _Tp, _Lp > __p, __shared_ptr< _Tp, _Lp > __v, __shared_ptr< _Tp, _Lp > __w, memory_order, memory_order)

bool	atomic_compare_exchange_strong (__shared_ptr< _Tp, _Lp > __p, __shared_ptr< _Tp, _Lp > __v, __shared_ptr< _Tp, _Lp > __w)

bool	atomic_compare_exchange_weak_explicit (__shared_ptr< _Tp, _Lp > __p, __shared_ptr< _Tp, _Lp > __v, __shared_ptr< _Tp, _Lp > __w, memory_order __success, memory_order __failure)

bool	atomic_compare_exchange_weak (__shared_ptr< _Tp, _Lp > __p, __shared_ptr< _Tp, _Lp > __v, __shared_ptr< _Tp, _Lp > __w)

bitset< _Nb >	operator& (const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept

unique_lock< _Lock >	__try_to_lock (_Lock &__l)

int	try_lock (_Lock1 &__l1, _Lock2 &__l2, _Lock3 &... __l3)

void	lock (_L1 &__l1, _L2 &__l2, _L3 &... __l3)

void	__once_proxy (void)

void	call_once (once_flag &__once, _Callable &&__f, _Args &&... __args)

void	swap (shared_lock< _Mutex > &__x, shared_lock< _Mutex > &__y) noexcept

epicsShareExtern std::ostream &	operator<< (std::ostream &o, const epics::pvData::PVField *ptr)

epicsShareExtern std::ostream &	operator<< (std::ostream &o, const epics::pvData::Field *ptr)

template<typename T >
std::ostream &	operator<< (std::ostream &strm, const ::detail::ref_shower< T > &refs)

Variables
	denorm_indeterminate

	denorm_absent

	denorm_present

	round_toward_zero

	round_to_nearest

	round_toward_infinity

	round_toward_neg_infinity

_GLIBCXX17_INLINE constexpr adopt_lock_t	adopt_lock

_GLIBCXX17_INLINE constexpr defer_lock_t	defer_lock

_GLIBCXX17_INLINE constexpr piecewise_construct_t	piecewise_construct

_GLIBCXX17_INLINE constexpr try_to_lock_t	try_to_lock

istream	cin

ostream	cout

ostream	cerr

ostream	clog

wistream	wcin

wostream	wcout

wostream	wcerr

wostream	wclog

istream	cin

ostream	cout

ostream	cerr

ostream	clog

wistream	wcin

wostream	wcout

wostream	wcerr

wostream	wclog

__thread void *	__once_callable

__thread void(*	__once_call )()

Detailed Description

stream support for pvField

stream support for Field

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description