Namespaces
namespace	__debug

namespace	__detail

namespace	__parallel

namespace	chrono

namespace	decimal

namespace	experimental

namespace	filesystem

namespace	literals

namespace	numbers

namespace	placeholders

namespace	regex_constants

namespace	rel_ops

namespace	this_thread

namespace	tr1

namespace	tr2

Classes
class	__basic_future

class	__codecvt_abstract_base

class	__ctype_abstract_base

struct	__is_fast_hash

struct	__is_location_invariant

struct	__is_nullptr_t

class	__new_allocator

struct	__numeric_limits_base

struct	_Base_bitset

struct	_Base_bitset< 0 >

struct	_Base_bitset< 1 >

class	_Bind

class	_Bind_result

class	_Deque_base

struct	_Deque_iterator

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	_List_base

struct	_List_const_iterator

struct	_List_iterator

struct	_List_node

class	_Node_handle

class	_Node_handle< _Value, _Value, _NodeAlloc >

class	_Node_handle_common

struct	_Node_insert_return

class	_Not_fn

struct	_Optional_base

struct	_Placeholder

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	add_const

struct	add_cv

struct	add_lvalue_reference

struct	add_pointer

struct	add_rvalue_reference

struct	add_volatile

struct	adopt_lock_t

struct	aligned_storage

struct	aligned_union

struct	alignment_of

class	allocator

class	allocator< void >

struct	allocator_traits

struct	allocator_traits< allocator< _Tp > >

struct	allocator_traits< allocator< void > >

struct	allocator_traits< pmr::polymorphic_allocator< _Tp > >

class	any

struct	array

class	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

struct	atomic_ref

class	auto_ptr

struct	auto_ptr_ref

class	back_insert_iterator

class	bad_alloc

class	bad_any_cast

class	bad_cast

class	bad_exception

class	bad_function_call

class	bad_optional_access

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_string_view

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

class	common_iterator

struct	common_type

struct	common_type< chrono::duration< _Rep, _Period > >

struct	common_type< chrono::duration< _Rep, _Period >, chrono::duration< _Rep, _Period > >

struct	common_type< chrono::duration< _Rep1, _Period1 >, chrono::duration< _Rep2, _Period2 > >

struct	common_type< chrono::time_point< _Clock, _Duration > >

struct	common_type< chrono::time_point< _Clock, _Duration >, chrono::time_point< _Clock, _Duration > >

struct	common_type< chrono::time_point< _Clock, _Duration1 >, chrono::time_point< _Clock, _Duration2 > >

struct	compare_three_way_result

class	complex

class	complex< double >

class	complex< float >

class	complex< long double >

class	condition_variable

class	condition_variable_any

struct	conditional

class	const_mem_fun1_ref_t

class	const_mem_fun1_t

class	const_mem_fun_ref_t

class	const_mem_fun_t

struct	contiguous_iterator_tag

class	counted_iterator

class	ctype

class	ctype< char >

class	ctype< wchar_t >

struct	ctype_base

class	ctype_byname

class	ctype_byname< char >

struct	decay

struct	default_delete

struct	default_delete< _Tp[]>

struct	default_sentinel_t

struct	defer_lock_t

class	deque

struct	destroying_delete_t

class	discard_block_engine

class	discrete_distribution

struct	divides

struct	divides< void >

class	domain_error

struct	enable_if

class	enable_shared_from_this

struct	equal_to

struct	equal_to< void >

class	error_category

class	error_code

class	error_condition

class	exception

class	exponential_distribution

struct	extent

class	extreme_value_distribution

class	fisher_f_distribution

struct	forward_iterator_tag

class	forward_list

class	fpos

struct	from_chars_result

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	has_unique_object_representations

struct	has_virtual_destructor

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< __gnu_debug::basic_string< _CharT > >

struct	hash< __shared_ptr< _Tp, _Lp > >

struct	hash< _Tp * >

struct	hash< basic_string< char, char_traits< char >, _Alloc > >

struct	hash< basic_string< char16_t, char_traits< char16_t >, _Alloc > >

struct	hash< basic_string< char32_t, char_traits< char32_t >, _Alloc > >

struct	hash< basic_string< wchar_t, char_traits< wchar_t >, _Alloc > >

struct	hash< bool >

struct	hash< char >

struct	hash< char16_t >

struct	hash< char32_t >

struct	hash< double >

struct	hash< error_code >

struct	hash< error_condition >

struct	hash< experimental::optional< _Tp > >

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< thread::id >

struct	hash< type_index >

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<::bitset< _Nb > >

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

struct	identity

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

struct	invoke_result

class	ios_base

struct	is_abstract

struct	is_aggregate

struct	is_arithmetic

struct	is_array

struct	is_assignable

struct	is_base_of

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_bounded_array

struct	is_class

struct	is_compound

struct	is_const

struct	is_constructible

struct	is_copy_assignable

struct	is_copy_constructible

struct	is_default_constructible

struct	is_destructible

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_invocable

struct	is_invocable_r

struct	is_layout_compatible

struct	is_literal_type

struct	is_lvalue_reference

struct	is_member_function_pointer

struct	is_member_object_pointer

struct	is_member_pointer

struct	is_move_assignable

struct	is_move_constructible

struct	is_nothrow_assignable

struct	is_nothrow_constructible

struct	is_nothrow_convertible

struct	is_nothrow_copy_assignable

struct	is_nothrow_copy_constructible

struct	is_nothrow_default_constructible

struct	is_nothrow_destructible

struct	is_nothrow_invocable

struct	is_nothrow_invocable_r

struct	is_nothrow_move_assignable

struct	is_nothrow_move_constructible

struct	is_nothrow_swappable

struct	is_nothrow_swappable_with

struct	is_null_pointer

struct	is_object

struct	is_placeholder

struct	is_placeholder< _Placeholder< _Num > >

struct	is_pod

struct	is_pointer

struct	is_pointer_interconvertible_base_of

struct	is_polymorphic

struct	is_reference

struct	is_rvalue_reference

struct	is_same

struct	is_scalar

struct	is_signed

struct	is_standard_layout

struct	is_swappable

struct	is_swappable_with

struct	is_trivial

struct	is_trivially_assignable

struct	is_trivially_constructible

struct	is_trivially_copy_assignable

struct	is_trivially_copy_constructible

struct	is_trivially_copyable

struct	is_trivially_default_constructible

struct	is_trivially_destructible

struct	is_trivially_move_assignable

struct	is_trivially_move_constructible

struct	is_unbounded_array

struct	is_union

struct	is_unsigned

struct	is_void

struct	is_volatile

class	istream_iterator

class	istreambuf_iterator

struct	iterator

struct	iterator_traits

struct	iterator_traits< _Tp * >

class	jthread

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

struct	make_signed

struct	make_unsigned

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	move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)>

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	nostopstate_t

struct	not_equal_to

struct	not_equal_to< void >

struct	nullopt_t

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	optional

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

struct	projected

class	promise

class	promise< _Res & >

class	promise< void >

class	queue

struct	random_access_iterator_tag

class	random_device

class	range_error

struct	rank

struct	ratio

struct	ratio_equal

struct	ratio_greater

struct	ratio_greater_equal

struct	ratio_less

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

struct	remove_all_extents

struct	remove_const

struct	remove_cv

struct	remove_extent

struct	remove_pointer

struct	remove_reference

struct	remove_volatile

struct	result_of

class	reverse_iterator

class	runtime_error

class	scoped_allocator_adaptor

class	scoped_lock

class	seed_seq

class	set

class	shared_future

class	shared_future< _Res & >

class	shared_future< void >

class	shared_lock

class	shared_mutex

class	shared_ptr

class	shared_timed_mutex

class	shuffle_order_engine

class	slice

class	slice_array

struct	source_location

class	stack

class	stop_callback

class	stop_source

class	stop_token

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	to_chars_result

struct	try_to_lock_t

class	tuple

class	tuple< _T1, _T2 >

struct	tuple_element

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

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

struct	tuple_element< __i, tuple< _Types... > >

struct	tuple_element< _Ind, array< _Tp, _Nm > >

struct	tuple_size

struct	tuple_size< array< _Tp, _Nm > >

struct	tuple_size< pair< _Tp1, _Tp2 > >

struct	tuple_size< tuple< _Elements... > >

struct	type_index

class	type_info

struct	unary_function

class	unary_negate

class	underflow_error

struct	underlying_type

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	unwrap_ref_decay

struct	unwrap_reference

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

Concepts
concept	same_as

concept	derived_from

concept	convertible_to

concept	common_reference_with

concept	common_with

concept	assignable_from

concept	destructible

concept	constructible_from

concept	default_initializable

concept	move_constructible

concept	copy_constructible

concept	invocable

concept	regular_invocable

concept	predicate

concept	relation

concept	equivalence_relation

concept	strict_weak_order

concept	indirectly_readable

concept	indirectly_writable

concept	weakly_incrementable

concept	indirectly_movable

concept	indirectly_copyable

concept	indirectly_swappable

concept	indirectly_comparable

concept	permutable

concept	mergeable

concept	sortable

concept	uniform_random_bit_generator

Typedefs
template<typename _Tp >
using	__allocator_base = __new_allocator< _Tp >

template<typename _Tp , typename _Up >
using	__assigns_from_optional = __or_< is_assignable< _Tp &, const optional< _Up > & >, is_assignable< _Tp &, optional< _Up > & >, is_assignable< _Tp &, const optional< _Up > && >, is_assignable< _Tp &, optional< _Up > && > >

typedef unsigned char	__atomic_flag_data_type

template<typename _RAIter , typename _Hash , typename _Pred , typename _Val = typename iterator_traits<_RAIter>::value_type, typename _Diff = typename iterator_traits<_RAIter>::difference_type>
using	__boyer_moore_base_t = __conditional_t< __is_byte_like< _Val, _Pred >::value, __boyer_moore_array_base< _Diff, 256, _Pred >, __boyer_moore_map_base< _Val, _Diff, _Hash, _Pred > >

template<typename _IntegerType >
using	__byte_op_t = typename __byte_operand< _IntegerType >::__type

typedef FILE	__c_file

typedef __locale_t	__c_locale

typedef __gthread_mutex_t	__c_lock

template<bool _Cond, typename _If , typename _Else >
using	__conditional_t = typename __conditional< _Cond >::template type< _If, _Else >

template<typename _Tp , typename _Up >
using	__converts_from_optional = __or_< is_constructible< _Tp, const optional< _Up > & >, is_constructible< _Tp, optional< _Up > & >, is_constructible< _Tp, const optional< _Up > && >, is_constructible< _Tp, optional< _Up > && >, is_convertible< const optional< _Up > &, _Tp >, is_convertible< optional< _Up > &, _Tp >, is_convertible< const optional< _Up > &&, _Tp >, is_convertible< optional< _Up > &&, _Tp > >

typedef basic_string< char >	__cow_string

template<typename _Tp >
using	__empty_not_final = __conditional_t< __is_final(_Tp), false_type, __is_empty_non_tuple< _Tp > >

template<typename _Tp , typename _Up = typename remove_cv<_Tp>::type, typename = typename enable_if<is_same<_Tp, _Up>::value>::type, size_t = tuple_size<_Tp>::value>
using	__enable_if_has_tuple_size = _Tp

template<bool _Cond, typename _Tp = void>
using	__enable_if_t = typename enable_if< _Cond, _Tp >::type

template<typename _Fn , typename _Op >
using	__function_guide_t = typename __function_guide_helper< _Op >::type

template<typename _Func , typename _SfinaeType >
using	__has_is_transparent_t = typename __has_is_transparent< _Func, _SfinaeType >::type

template<typename _ToElementType , typename _FromElementType >
using	__is_array_convertible = is_convertible< _FromElementType()[], _ToElementType()[]>

template<typename _Tp >
using	__is_in_place_type = bool_constant< __is_in_place_type_v< _Tp > >

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

template<typename _InputIterator >
using	__iter_key_t = remove_const_t< typename iterator_traits< _InputIterator >::value_type::first_type >

template<typename _InputIterator >
using	__iter_to_alloc_t = pair< const __iter_key_t< _InputIterator >, __iter_val_t< _InputIterator > >

template<typename _InputIterator >
using	__iter_val_t = typename iterator_traits< _InputIterator >::value_type::second_type

template<typename _Iter >
using	__iterator_category_t = typename iterator_traits< _Iter >::iterator_category

template<typename _Tp , typename _Up >
using	__optional_eq_t = __optional_relop_t< decltype(std::declval< const _Tp & >()==std::declval< const _Up & >()) >

template<typename _Tp , typename _Up >
using	__optional_ge_t = __optional_relop_t< decltype(std::declval< const _Tp & >() >=std::declval< const _Up & >()) >

template<typename _Tp , typename _Up >
using	__optional_gt_t = __optional_relop_t< decltype(std::declval< const _Tp & >() > std::declval< const _Up & >()) >

template<typename _Tp , typename _Up >
using	__optional_le_t = __optional_relop_t< decltype(std::declval< const _Tp & >()<=std::declval< const _Up & >()) >

template<typename _Tp , typename _Up >
using	__optional_lt_t = __optional_relop_t< decltype(std::declval< const _Tp & >()< std::declval< const _Up & >()) >

template<typename _Tp , typename _Up >
using	__optional_ne_t = __optional_relop_t< decltype(std::declval< const _Tp & >() !=std::declval< const _Up & >()) >

template<typename _Tp >
using	__optional_relop_t = enable_if_t< is_convertible< _Tp, bool >::value, bool >

template<typename _Ptr , typename _Tp >
using	__ptr_rebind = typename pointer_traits< _Ptr >::template rebind< _Tp >

template<typename _Is , typename _Tp >
using	__rvalue_stream_extraction_t = _Is &&

template<typename _Os , typename _Tp >
using	__rvalue_stream_insertion_t = _Os &&

using	__semaphore_impl = __atomic_semaphore

typedef basic_string< char >	__sso_string

template<size_t __i, typename _Tp >
using	__tuple_element_t = typename tuple_element< __i, _Tp >::type

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

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

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

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

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

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

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

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

template<typename _Fn , typename... _Args>
using	_Bind_front_t = _Bind_front< decay_t< _Fn >, decay_t< _Args >... >

typedef unsigned long	_Bit_type

template<typename _Path , typename _Result = _Path, typename _Path2 = decltype(std::declval<_Path&>().make_preferred().filename())>
using	_If_fs_path = enable_if_t< is_same_v< _Path, _Path2 >, _Result >

template<typename _InIter >
using	_RequireInputIter = __enable_if_t< is_convertible< __iterator_category_t< _InIter >, input_iterator_tag >::value >

template<typename _Tp >
using	add_const_t = typename add_const< _Tp >::type

template<typename _Tp >
using	add_cv_t = typename add_cv< _Tp >::type

template<typename _Tp >
using	add_lvalue_reference_t = typename add_lvalue_reference< _Tp >::type

template<typename _Tp >
using	add_pointer_t = typename add_pointer< _Tp >::type

template<typename _Tp >
using	add_rvalue_reference_t = typename add_rvalue_reference< _Tp >::type

template<typename _Tp >
using	add_volatile_t = typename add_volatile< _Tp >::type

template<size_t _Len, size_t _Align = __alignof__(typename __aligned_storage_msa<_Len>::__type)>
using	aligned_storage_t = typename aligned_storage< _Len, _Align >::type

template<size_t _Len, typename... _Types>
using	aligned_union_t = typename aligned_union< _Len, _Types... >::type

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 ratio< 1, 1000000000000000000 >	atto

using	binary_semaphore = std::counting_semaphore< 1 >

template<bool __v>
using	bool_constant = integral_constant< bool, __v >

typedef ratio< 1, 100 >	centi

typedef match_results< const char * >	cmatch

template<typename... _Ts>
using	common_comparison_category_t = typename common_comparison_category< _Ts... >::type

template<typename... _Tp>
using	common_reference_t = typename common_reference< _Tp... >::type

template<typename... _Tp>
using	common_type_t = typename common_type< _Tp... >::type

template<typename _Tp , typename _Up = _Tp>
using	compare_three_way_result_t = typename __detail::__cmp3way_res_impl< _Tp, _Up >::type

template<bool _Cond, typename _Iftrue , typename _Iffalse >
using	conditional_t = typename conditional< _Cond, _Iftrue, _Iffalse >::type

typedef regex_iterator< const char * >	cregex_iterator

typedef regex_token_iterator< const char * >	cregex_token_iterator

typedef sub_match< const char * >	csub_match

typedef ratio< 10, 1 >	deca

template<typename _Tp >
using	decay_t = typename decay< _Tp >::type

typedef ratio< 1, 10 >	deci

typedef minstd_rand0	default_random_engine

template<bool _Cond, typename _Tp = void>
using	enable_if_t = typename enable_if< _Cond, _Tp >::type

typedef ratio< 1000000000000000000, 1 >	exa

using	false_type = integral_constant< bool, false >

typedef ratio< 1, 1000000000000000 >	femto

typedef basic_filebuf< char >	filebuf

typedef basic_fstream< char >	fstream

typedef ratio< 1000000000, 1 >	giga

typedef ratio< 100, 1 >	hecto

typedef basic_ifstream< char >	ifstream

template<size_t... _Idx>
using	index_sequence = integer_sequence< size_t, _Idx... >

template<typename... _Types>
using	index_sequence_for = make_index_sequence< sizeof...(_Types)>

template<typename _Fn , typename... _Is>
using	indirect_result_t = invoke_result_t< _Fn, iter_reference_t< _Is >... >

template<typename _Fn , typename... _Args>
using	invoke_result_t = typename invoke_result< _Fn, _Args... >::type

typedef basic_ios< char >	ios

typedef basic_iostream< char >	iostream

typedef basic_istream< char >	istream

typedef basic_istringstream< char >	istringstream

template<indirectly_readable _Tp>
using	iter_common_reference_t = common_reference_t< iter_reference_t< _Tp >, iter_value_t< _Tp > & >

template<typename _Tp >
using	iter_difference_t = __detail::__iter_diff_t< remove_cvref_t< _Tp > >

template<__detail::__dereferenceable _Tp>
using	iter_reference_t = decltype(*std::declval< _Tp & >())

template<__detail::__dereferenceable _Tp>
using	iter_rvalue_reference_t = ranges::__cust_imove::_IMove::__type< _Tp & >

template<typename _Tp >
using	iter_value_t = __detail::__iter_value_t< remove_cvref_t< _Tp > >

typedef ratio< 1000, 1 >	kilo

typedef shuffle_order_engine< minstd_rand0, 256 >	knuth_b

template<size_t _Num>
using	make_index_sequence = make_integer_sequence< size_t, _Num >

template<typename _Tp , _Tp _Num>
using	make_integer_sequence = __make_integer_seq< integer_sequence, _Tp, _Num >

template<typename _Tp >
using	make_signed_t = typename make_signed< _Tp >::type

template<typename _Tp >
using	make_unsigned_t = typename make_unsigned< _Tp >::type

typedef ratio< 1000000, 1 >	mega

typedef ratio< 1, 1000000 >	micro

typedef ratio< 1, 1000 >	milli

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 ratio< 1, 1000000000 >	nano

typedef void(*	new_handler) ()

typedef decltype(nullptr)	nullptr_t

typedef basic_ofstream< char >	ofstream

typedef basic_ostream< char >	ostream

typedef basic_ostringstream< char >	ostringstream

typedef ratio< 1000000000000000, 1 >	peta

typedef ratio< 1, 1000000000000 >	pico

typedef __PTRDIFF_TYPE__	ptrdiff_t

typedef discard_block_engine< ranlux24_base, 223, 23 >	ranlux24

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

typedef discard_block_engine< ranlux48_base, 389, 11 >	ranlux48

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

template<typename _R1 , typename _R2 >
using	ratio_add = typename __ratio_add< _R1, _R2 >::type

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

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

template<typename _R1 , typename _R2 >
using	ratio_subtract = typename __ratio_subtract< _R1, _R2 >::type

typedef basic_regex< char >	regex

template<typename _Tp >
using	remove_all_extents_t = typename remove_all_extents< _Tp >::type

template<typename _Tp >
using	remove_const_t = typename remove_const< _Tp >::type

template<typename _Tp >
using	remove_cv_t = typename remove_cv< _Tp >::type

template<typename _Tp >
using	remove_extent_t = typename remove_extent< _Tp >::type

template<typename _Tp >
using	remove_pointer_t = typename remove_pointer< _Tp >::type

template<typename _Tp >
using	remove_reference_t = typename remove_reference< _Tp >::type

template<typename _Tp >
using	remove_volatile_t = typename remove_volatile< _Tp >::type

template<typename _Tp >
using	result_of_t = typename result_of< _Tp >::type

typedef __SIZE_TYPE__	size_t

typedef match_results< string::const_iterator >	smatch

typedef regex_iterator< string::const_iterator >	sregex_iterator

typedef regex_token_iterator< string::const_iterator >	sregex_token_iterator

typedef sub_match< string::const_iterator >	ssub_match

typedef basic_streambuf< char >	streambuf

typedef long long	streamoff

typedef fpos< mbstate_t >	streampos

typedef ptrdiff_t	streamsize

typedef basic_string< char >	string

using	string_view = basic_string_view< char >

typedef basic_stringbuf< char >	stringbuf

typedef basic_stringstream< char >	stringstream

typedef ratio< 1000000000000, 1 >	tera

typedef void(*	terminate_handler) ()

using	true_type = integral_constant< bool, true >

template<size_t __i, typename _Tp >
using	tuple_element_t = typename tuple_element< __i, _Tp >::type

typedef fpos< mbstate_t >	u16streampos

typedef basic_string< char16_t >	u16string

using	u16string_view = basic_string_view< char16_t >

typedef fpos< mbstate_t >	u32streampos

typedef basic_string< char32_t >	u32string

using	u32string_view = basic_string_view< char32_t >

template<typename _Tp >
using	underlying_type_t = typename underlying_type< _Tp >::type

typedef void(*	unexpected_handler) ()

template<size_t _Np, typename _Variant >
using	variant_alternative_t = typename variant_alternative< _Np, _Variant >::type

template<typename... >
using	void_t = void

typedef match_results< const wchar_t * >	wcmatch

typedef regex_iterator< const wchar_t * >	wcregex_iterator

typedef regex_token_iterator< const wchar_t * >	wcregex_token_iterator

typedef sub_match< const wchar_t * >	wcsub_match

typedef basic_filebuf< wchar_t >	wfilebuf

typedef basic_fstream< wchar_t >	wfstream

typedef basic_ifstream< wchar_t >	wifstream

typedef basic_ios< wchar_t >	wios

typedef basic_iostream< wchar_t >	wiostream

typedef basic_istream< wchar_t >	wistream

typedef basic_istringstream< wchar_t >	wistringstream

typedef basic_ofstream< wchar_t >	wofstream

typedef basic_ostream< wchar_t >	wostream

typedef basic_ostringstream< wchar_t >	wostringstream

typedef basic_regex< wchar_t >	wregex

typedef match_results< wstring::const_iterator >	wsmatch

typedef regex_iterator< wstring::const_iterator >	wsregex_iterator

typedef regex_token_iterator< wstring::const_iterator >	wsregex_token_iterator

typedef sub_match< wstring::const_iterator >	wssub_match

typedef basic_streambuf< wchar_t >	wstreambuf

typedef fpos< mbstate_t >	wstreampos

typedef basic_string< wchar_t >	wstring

using	wstring_view = basic_string_view< wchar_t >

typedef basic_stringbuf< wchar_t >	wstringbuf

typedef basic_stringstream< wchar_t >	wstringstream


template<typename _Tp >
using	remove_cvref_t = typename remove_cvref< _Tp >::type


template<typename _Tp >
using	type_identity_t = typename type_identity< _Tp >::type


template<typename _Tp >
using	unwrap_reference_t = typename unwrap_reference< _Tp >::type


template<typename _Tp >
using	unwrap_ref_decay_t = typename unwrap_ref_decay< _Tp >::type

Enumerations
enum	{ _S_chunk_size }

enum	{ _S_word_bit }

enum class	__barrier_phase_t : unsigned char

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

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

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

enum	_Ios_Seekdir { _S_beg , _S_cur , _S_end , _S_ios_seekdir_end }

enum	_Manager_operation { __get_type_info , __get_functor_ptr , __clone_functor , __destroy_functor }

enum	_Rb_tree_color { _S_red , _S_black }

enum class	align_val_t : size_t

enum class	byte : unsigned char

enum class	chars_format { scientific , fixed , hex , general }

enum	codecvt_mode { consume_header , generate_header , little_endian }

enum class	cv_status { no_timeout , timeout }

enum class	endian { little , big , native }

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

enum	float_denorm_style { denorm_indeterminate , denorm_absent , denorm_present }

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

enum class	future_errc { future_already_retrieved , promise_already_satisfied , no_state , broken_promise }

enum class	future_status { ready , timeout , deferred }

enum class	io_errc { stream }

enum class	launch { async , deferred }

enum class	memory_order : int { relaxed , consume , acquire , release , acq_rel , seq_cst }

enum class	pointer_safety { relaxed , preferred , strict }

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

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

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

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

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

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

template<typename _OutputIterator , typename _Distance >
void	__advance (_OutputIterator &, _Distance, output_iterator_tag)=delete

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

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

template<typename _Fn , typename _Tuple , size_t... _Idx>
constexpr decltype(auto)	__apply_impl (_Fn &&__f, _Tuple &&__t, index_sequence< _Idx... >)

template<typename _Tp >
void	__atomic_notify_address (const _Tp *__addr, bool __all) noexcept

void	__atomic_notify_address_bare (const __detail::__platform_wait_t *__addr, bool __all) noexcept

template<typename _Tp , typename _Pred >
void	__atomic_wait_address (const _Tp *__addr, _Pred __pred) noexcept

template<typename _Pred >
void	__atomic_wait_address_bare (const __detail::__platform_wait_t *__addr, _Pred __pred) noexcept

template<typename _Tp , typename _Pred , typename _Rep , typename _Period >
bool	__atomic_wait_address_for (const _Tp *__addr, _Pred __pred, const chrono::duration< _Rep, _Period > &__rtime) noexcept

template<typename _Pred , typename _Rep , typename _Period >
bool	__atomic_wait_address_for_bare (const __detail::__platform_wait_t *__addr, _Pred __pred, const chrono::duration< _Rep, _Period > &__rtime) noexcept

template<typename _Tp , typename _ValFn , typename _Rep , typename _Period >
bool	__atomic_wait_address_for_v (const _Tp *__addr, _Tp &&__old, _ValFn &&__vfn, const chrono::duration< _Rep, _Period > &__rtime) noexcept

template<typename _Tp , typename _Pred , typename _Clock , typename _Dur >
bool	__atomic_wait_address_until (const _Tp *__addr, _Pred __pred, const chrono::time_point< _Clock, _Dur > &__atime) noexcept

template<typename _Pred , typename _Clock , typename _Dur >
bool	__atomic_wait_address_until_bare (const __detail::__platform_wait_t *__addr, _Pred __pred, const chrono::time_point< _Clock, _Dur > &__atime) noexcept

template<typename _Tp , typename _ValFn , typename _Clock , typename _Dur >
bool	__atomic_wait_address_until_v (const _Tp *__addr, _Tp &&__old, _ValFn &&__vfn, const chrono::time_point< _Clock, _Dur > &__atime) noexcept

template<typename _Tp , typename _ValFn >
void	__atomic_wait_address_v (const _Tp *__addr, _Tp __old, _ValFn __vfn) noexcept

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<bool _IsMove, typename _II , typename _Ite , typename _Seq , typename _Cat >
__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat >	__copy_move_a (_II, _II, const ::__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat > &)

template<bool _IsMove, typename _IIte , typename _ISeq , typename _ICat , typename _OIte , typename _OSeq , typename _OCat >
::__gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat >	__copy_move_a (const ::__gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat > &, const ::__gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat > &, const ::__gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat > &)

template<bool _IsMove, typename _Ite , typename _Seq , typename _Cat , typename _OI >
_OI	__copy_move_a (const ::__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat > &, const ::__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat > &, _OI)

template<bool _IsMove, typename _ITp , typename _IRef , typename _IPtr , typename _OTp >
::_Deque_iterator< _OTp, _OTp &, _OTp * >	__copy_move_a1 (::_Deque_iterator< _ITp, _IRef, _IPtr > __first, ::_Deque_iterator< _ITp, _IRef, _IPtr > __last, ::_Deque_iterator< _OTp, _OTp &, _OTp * > __result)

template<bool _IsMove, typename _Tp , typename _Ref , typename _Ptr , typename _OI >
_OI	__copy_move_a1 (::_Deque_iterator< _Tp, _Ref, _Ptr > __first, ::_Deque_iterator< _Tp, _Ref, _Ptr > __last, _OI __result)

template<bool _IsMove, typename _II , typename _Tp >
__gnu_cxx::__enable_if< __is_random_access_iter< _II >::__value,::_Deque_iterator< _Tp, _Tp &, _Tp * > >::__type	__copy_move_a1 (_II __first, _II __last, ::_Deque_iterator< _Tp, _Tp &, _Tp * > __result)

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

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

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

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

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

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

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

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

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

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

template<bool _IsMove, typename _II , typename _Ite , typename _Seq , typename _Cat >
__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat >	__copy_move_backward_a (_II, _II, const ::__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat > &)

template<bool _IsMove, typename _IIte , typename _ISeq , typename _ICat , typename _OIte , typename _OSeq , typename _OCat >
::__gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat >	__copy_move_backward_a (const ::__gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat > &, const ::__gnu_debug::_Safe_iterator< _IIte, _ISeq, _ICat > &, const ::__gnu_debug::_Safe_iterator< _OIte, _OSeq, _OCat > &)

template<bool _IsMove, typename _Ite , typename _Seq , typename _Cat , typename _OI >
_OI	__copy_move_backward_a (const ::__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat > &, const ::__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat > &, _OI)

template<bool _IsMove, typename _ITp , typename _IRef , typename _IPtr , typename _OTp >
::_Deque_iterator< _OTp, _OTp &, _OTp * >	__copy_move_backward_a1 (::_Deque_iterator< _ITp, _IRef, _IPtr > __first, ::_Deque_iterator< _ITp, _IRef, _IPtr > __last, ::_Deque_iterator< _OTp, _OTp &, _OTp * > __result)

template<bool _IsMove, typename _Tp , typename _Ref , typename _Ptr , typename _OI >
_OI	__copy_move_backward_a1 (::_Deque_iterator< _Tp, _Ref, _Ptr > __first, ::_Deque_iterator< _Tp, _Ref, _Ptr > __last, _OI __result)

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

template<bool _IsMove, typename _II , typename _Tp >
__gnu_cxx::__enable_if< __is_random_access_iter< _II >::__value,::_Deque_iterator< _Tp, _Tp &, _Tp * > >::__type	__copy_move_backward_a1 (_II __first, _II __last, ::_Deque_iterator< _Tp, _Tp &, _Tp * > __result)

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

template<bool _IsMove, typename _Tp , typename _Ref , typename _Ptr , typename _OI >
_OI	__copy_move_backward_dit (::_Deque_iterator< _Tp, _Ref, _Ptr > __first, ::_Deque_iterator< _Tp, _Ref, _Ptr > __last, _OI __result)

template<bool _IsMove, typename _Tp , typename _Ref , typename _Ptr , typename _OI >
_OI	__copy_move_dit (::_Deque_iterator< _Tp, _Ref, _Ptr > __first, ::_Deque_iterator< _Tp, _Ref, _Ptr > __last, _OI __result)

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

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

template<typename _InputIterator , typename _Size , typename _OutputIterator >
constexpr _OutputIterator	__copy_n_a (_InputIterator __first, _Size __n, _OutputIterator __result, bool)

template<typename _CharT , typename _Size >
__gnu_cxx::__enable_if< __is_char< _CharT >::__value, _CharT * >::__type	__copy_n_a (istreambuf_iterator< _CharT > __it, _Size __n, _CharT *__result, bool __strict)

template<typename _CharT , typename _Size >
__gnu_cxx::__enable_if< __is_char< _CharT >::__value,::_Deque_iterator< _CharT, _CharT &, _CharT * > >::__type	__copy_n_a (istreambuf_iterator< _CharT, char_traits< _CharT > > __it, _Size __size, ::_Deque_iterator< _CharT, _CharT &, _CharT * > __result, bool __strict)

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

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

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

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

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

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

constexpr size_t	__deque_buf_size (size_t __size)

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

template<typename _OutputIterator >
void	__distance (_OutputIterator, _OutputIterator, output_iterator_tag)=delete

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

template<typename _OutStr , typename _InChar , typename _Codecvt , typename _State , typename _Fn >
bool	__do_str_codecvt (const _InChar __first, const _InChar __last, _OutStr &__outstr, const _Codecvt &__cvt, _State &__state, size_t &__count, _Fn __fn)

template<typename _Result_type , typename _Visitor , typename... _Variants>
constexpr decltype(auto)	__do_visit (_Visitor &&__visitor, _Variants &&... __variants)

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

template<typename _II1 , typename _II2 , typename _BinaryPredicate >
constexpr bool	__equal4 (_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _BinaryPredicate __binary_pred)

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

template<typename _II1 , typename _II2 , typename _Seq2 , typename _Cat2 >
bool	__equal_aux (_II1, _II1, const ::__gnu_debug::_Safe_iterator< _II2, _Seq2, _Cat2 > &)

template<typename _II1 , typename _Seq1 , typename _Cat1 , typename _II2 >
bool	__equal_aux (const ::__gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1 > &, const ::__gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1 > &, _II2)

template<typename _II1 , typename _Seq1 , typename _Cat1 , typename _II2 , typename _Seq2 , typename _Cat2 >
bool	__equal_aux (const ::__gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1 > &, const ::__gnu_debug::_Safe_iterator< _II1, _Seq1, _Cat1 > &, const ::__gnu_debug::_Safe_iterator< _II2, _Seq2, _Cat2 > &)

template<typename _Tp , typename _Ref , typename _Ptr , typename _II >
__gnu_cxx::__enable_if< __is_random_access_iter< _II >::__value, bool >::__type	__equal_aux1 (::_Deque_iterator< _Tp, _Ref, _Ptr > __first1, ::_Deque_iterator< _Tp, _Ref, _Ptr > __last1, _II __first2)

template<typename _Tp1 , typename _Ref1 , typename _Ptr1 , typename _Tp2 , typename _Ref2 , typename _Ptr2 >
bool	__equal_aux1 (::_Deque_iterator< _Tp1, _Ref1, _Ptr1 > __first1, ::_Deque_iterator< _Tp1, _Ref1, _Ptr1 > __last1, ::_Deque_iterator< _Tp2, _Ref2, _Ptr2 > __first2)

template<typename _II , typename _Tp , typename _Ref , typename _Ptr >
__gnu_cxx::__enable_if< __is_random_access_iter< _II >::__value, bool >::__type	__equal_aux1 (_II __first1, _II __last1, ::_Deque_iterator< _Tp, _Ref, _Ptr > __first2)

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

template<typename _Tp , typename _Ref , typename _Ptr , typename _II >
bool	__equal_dit (const ::_Deque_iterator< _Tp, _Ref, _Ptr > &__first1, const ::_Deque_iterator< _Tp, _Ref, _Ptr > &__last1, _II __first2)

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

template<typename _Tp , typename _Up = _Tp>
constexpr _Tp	__exchange (_Tp &__obj, _Up &&__new_val)

template<typename _FIte , typename _Tp >
constexpr void	__fill_a (_FIte __first, _FIte __last, const _Tp &__value)

template<typename _Ite , typename _Seq , typename _Cat , typename _Tp >
void	__fill_a (const ::__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat > &, const ::__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat > &, const _Tp &)

template<typename _Ite , typename _Cont , typename _Tp >
constexpr void	__fill_a1 (::__gnu_cxx::__normal_iterator< _Ite, _Cont > __first, ::__gnu_cxx::__normal_iterator< _Ite, _Cont > __last, const _Tp &__value)

constexpr void	__fill_a1 (::_Bit_iterator, ::_Bit_iterator, const bool &)

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

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

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

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

constexpr void	__fill_bvector (_Bit_type *__v, unsigned int __first, unsigned int __last, bool __x) noexcept

constexpr void	__fill_bvector_n (_Bit_type *, size_t, bool) noexcept

template<typename _OutputIterator , typename _Size , typename _Tp >
constexpr _OutputIterator	__fill_n_a (_OutputIterator __first, _Size __n, const _Tp &__value, std::input_iterator_tag)

template<typename _OutputIterator , typename _Size , typename _Tp >
constexpr _OutputIterator	__fill_n_a (_OutputIterator __first, _Size __n, const _Tp &__value, std::output_iterator_tag)

template<typename _OutputIterator , typename _Size , typename _Tp >
constexpr _OutputIterator	__fill_n_a (_OutputIterator __first, _Size __n, const _Tp &__value, std::random_access_iterator_tag)

template<typename _Ite , typename _Seq , typename _Cat , typename _Size , typename _Tp >
::__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat >	__fill_n_a (const ::__gnu_debug::_Safe_iterator< _Ite, _Seq, _Cat > &__first, _Size __n, const _Tp &__value, std::input_iterator_tag)

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

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

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

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

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

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

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

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

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

template<typename _Tp , typename... _Types>
constexpr size_t	__find_uniq_type_in_pack ()

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

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

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

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

template<size_t __i, typename... _Types>
__enable_if_t<(__i >=sizeof...(_Types))>	__get_helper (const tuple< _Types... > &)=delete

template<typename _Tp >
_Tp	__hypot3 (_Tp __x, _Tp __y, _Tp __z)

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

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

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

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

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

template<typename _Tp , typename _Up = typename __inv_unwrap<_Tp>::type>
constexpr _Up &&	__invfwd (typename remove_reference< _Tp >::type &__t) noexcept

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

template<typename _Res , typename _MemFun , typename _Tp , typename... _Args>
constexpr _Res	__invoke_impl (__invoke_memfun_deref, _MemFun &&__f, _Tp &&__t, _Args &&... __args)

template<typename _Res , typename _MemFun , typename _Tp , typename... _Args>
constexpr _Res	__invoke_impl (__invoke_memfun_ref, _MemFun &&__f, _Tp &&__t, _Args &&... __args)

template<typename _Res , typename _MemPtr , typename _Tp >
constexpr _Res	__invoke_impl (__invoke_memobj_deref, _MemPtr &&__f, _Tp &&__t)

template<typename _Res , typename _MemPtr , typename _Tp >
constexpr _Res	__invoke_impl (__invoke_memobj_ref, _MemPtr &&__f, _Tp &&__t)

template<typename _Res , typename _Fn , typename... _Args>
constexpr _Res	__invoke_impl (__invoke_other, _Fn &&__f, _Args &&... __args)

template<typename _Res , typename _Callable , typename... _Args>
constexpr enable_if_t< is_invocable_r_v< _Res, _Callable, _Args... >, _Res >	__invoke_r (_Callable &&__fn, _Args &&... __args) noexcept(is_nothrow_invocable_r_v< _Res, _Callable, _Args... >)

constexpr bool	__is_constant_evaluated () noexcept

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

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

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

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

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

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

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

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

template<typename _CharT , typename _Traits >
void	__istream_extract (basic_istream< _CharT, _Traits > &, _CharT *, streamsize)

void	__istream_extract (istream &, char *, streamsize)

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

template<typename _Fp >
constexpr _Fp	__lerp (_Fp __a, _Fp __b, _Fp __t) noexcept

template<typename _Tp1 , typename _Ref , typename _Ptr , typename _Tp2 >
int	__lex_cmp_dit (::_Deque_iterator< _Tp1, _Ref, _Ptr > __first1, ::_Deque_iterator< _Tp1, _Ref, _Ptr > __last1, const _Tp2 __first2, const _Tp2 __last2)

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

template<typename _II1 , typename _Ite2 , typename _Seq2 , typename _Cat2 >
bool	__lexicographical_compare_aux (_II1 __first1, _II1 __last1, const ::__gnu_debug::_Safe_iterator< _Ite2, _Seq2, _Cat2 > &__first2, const ::__gnu_debug::_Safe_iterator< _Ite2, _Seq2, _Cat2 > &__last2)

template<typename _II1 , typename _Iter2 , typename _Seq2 , typename _Cat2 >
bool	__lexicographical_compare_aux (_II1, _II1, const ::__gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2 > &, const ::__gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2 > &)

template<typename _Ite1 , typename _Seq1 , typename _Cat1 , typename _II2 >
bool	__lexicographical_compare_aux (const ::__gnu_debug::_Safe_iterator< _Ite1, _Seq1, _Cat1 > &__first1, const ::__gnu_debug::_Safe_iterator< _Ite1, _Seq1, _Cat1 > &__last1, _II2 __first2, _II2 __last2)

template<typename _Ite1 , typename _Seq1 , typename _Cat1 , typename _Ite2 , typename _Seq2 , typename _Cat2 >
bool	__lexicographical_compare_aux (const ::__gnu_debug::_Safe_iterator< _Ite1, _Seq1, _Cat1 > &__first1, const ::__gnu_debug::_Safe_iterator< _Ite1, _Seq1, _Cat1 > &__last1, const ::__gnu_debug::_Safe_iterator< _Ite2, _Seq2, _Cat2 > &__first2, const ::__gnu_debug::_Safe_iterator< _Ite2, _Seq2, _Cat2 > &__last2)

template<typename _Iter1 , typename _Seq1 , typename _Cat1 , typename _II2 >
bool	__lexicographical_compare_aux (const ::__gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1 > &, const ::__gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1 > &, _II2, _II2)

template<typename _Iter1 , typename _Seq1 , typename _Cat1 , typename _Iter2 , typename _Seq2 , typename _Cat2 >
bool	__lexicographical_compare_aux (const ::__gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1 > &, const ::__gnu_debug::_Safe_iterator< _Iter1, _Seq1, _Cat1 > &, const ::__gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2 > &, const ::__gnu_debug::_Safe_iterator< _Iter2, _Seq2, _Cat2 > &)

template<typename _Tp1 , typename _Ref1 , typename _Ptr1 , typename _Tp2 , typename _Ref2 , typename _Ptr2 >
bool	__lexicographical_compare_aux1 (::_Deque_iterator< _Tp1, _Ref1, _Ptr1 > __first1, ::_Deque_iterator< _Tp1, _Ref1, _Ptr1 > __last1, ::_Deque_iterator< _Tp2, _Ref2, _Ptr2 > __first2, ::_Deque_iterator< _Tp2, _Ref2, _Ptr2 > __last2)

template<typename _Tp1 , typename _Ref1 , typename _Ptr1 , typename _Tp2 >
bool	__lexicographical_compare_aux1 (::_Deque_iterator< _Tp1, _Ref1, _Ptr1 > __first1, ::_Deque_iterator< _Tp1, _Ref1, _Ptr1 > __last1, _Tp2 __first2, _Tp2 __last2)

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

template<typename _Tp1 , typename _Tp2 , typename _Ref2 , typename _Ptr2 >
bool	__lexicographical_compare_aux1 (_Tp1 __first1, _Tp1 __last1, ::_Deque_iterator< _Tp2, _Ref2, _Ptr2 > __first2, ::_Deque_iterator< _Tp2, _Ref2, _Ptr2 > __last2)

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

constexpr int	__lg (int __n)

constexpr long	__lg (long __n)

constexpr long long	__lg (long long __n)

constexpr unsigned	__lg (unsigned __n)

constexpr unsigned long	__lg (unsigned long __n)

constexpr unsigned long long	__lg (unsigned long long __n)

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

template<typename _Tp , typename _Tuple , size_t... _Idx>
constexpr _Tp	__make_from_tuple_impl (_Tuple &&__t, index_sequence< _Idx... >)

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

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

template<typename _Tp , typename _ReturnType = __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp, move_iterator<_Tp>>>
constexpr _ReturnType	__make_move_if_noexcept_iterator (_Tp *__i)

template<typename _Iterator >
constexpr reverse_iterator< _Iterator >	__make_reverse_iterator (_Iterator __i)

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

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

template<typename _Tp , typename _Up >
constexpr int	__memcmp (const _Tp __first1, const _Up __first2, size_t __num)

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

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

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

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

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

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

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

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

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

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

template<typename _Iterator >
constexpr _Iterator	__miter_base (_Iterator __it)

template<typename _Iterator >
constexpr auto	__miter_base (move_iterator< _Iterator > __it) -> decltype(__miter_base(__it.base()))

template<typename _Iterator >
constexpr auto	__miter_base (reverse_iterator< _Iterator > __it) -> decltype(__make_reverse_iterator(__miter_base(__it.base())))

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

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

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

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

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

template<typename _Iterator , typename _Container >
constexpr _Iterator	__niter_base (__gnu_cxx::__normal_iterator< _Iterator, _Container > __it) noexcept(/conditional /)

template<typename _Iterator >
constexpr _Iterator	__niter_base (_Iterator __it) noexcept(/conditional /)

template<typename _Ite , typename _Seq >
_Ite	__niter_base (const ::__gnu_debug::_Safe_iterator< _Ite, _Seq, std::random_access_iterator_tag > &)

template<typename _Iterator >
constexpr auto	__niter_base (move_iterator< _Iterator > __it) -> decltype(make_move_iterator(__niter_base(__it.base())))

template<typename _Iterator >
constexpr auto	__niter_base (reverse_iterator< _Iterator > __it) -> decltype(__make_reverse_iterator(__niter_base(__it.base())))

template<typename _From , typename _To >
constexpr _From	__niter_wrap (_From __from, _To __res)

template<typename _Iterator >
constexpr _Iterator	__niter_wrap (const _Iterator &, _Iterator __res)

void	__once_proxy (void)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

constexpr long long	__size_to_integer (double __n)

constexpr long long	__size_to_integer (float __n)

constexpr int	__size_to_integer (int __n)

constexpr long	__size_to_integer (long __n)

constexpr long long	__size_to_integer (long double __n)

constexpr long long	__size_to_integer (long long __n)

constexpr unsigned	__size_to_integer (unsigned __n)

constexpr unsigned long	__size_to_integer (unsigned long __n)

constexpr unsigned long long	__size_to_integer (unsigned long long __n)

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

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

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

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

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

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

template<typename _CharT , typename _Traits , typename _Alloc , typename _State >
bool	__str_codecvt_in (const char __first, const char __last, basic_string< _CharT, _Traits, _Alloc > &__outstr, const codecvt< _CharT, char, _State > &__cvt)

template<typename _CharT , typename _Traits , typename _Alloc , typename _State >
bool	__str_codecvt_in (const char __first, const char __last, basic_string< _CharT, _Traits, _Alloc > &__outstr, const codecvt< _CharT, char, _State > &__cvt, _State &__state, size_t &__count)

template<typename _CharT , typename _Traits , typename _Alloc , typename _State >
bool	__str_codecvt_in_all (const char __first, const char __last, basic_string< _CharT, _Traits, _Alloc > &__outstr, const codecvt< _CharT, char, _State > &__cvt)

template<typename _CharT , typename _Traits , typename _Alloc , typename _State >
bool	__str_codecvt_out (const _CharT __first, const _CharT __last, basic_string< char, _Traits, _Alloc > &__outstr, const codecvt< _CharT, char, _State > &__cvt)

template<typename _CharT , typename _Traits , typename _Alloc , typename _State >
bool	__str_codecvt_out (const _CharT __first, const _CharT __last, basic_string< char, _Traits, _Alloc > &__outstr, const codecvt< _CharT, char, _State > &__cvt, _State &__state, size_t &__count)

template<typename _CharT , typename _Traits , typename _Alloc , typename _State >
bool	__str_codecvt_out_all (const _CharT __first, const _CharT __last, basic_string< char, _Traits, _Alloc > &__outstr, const codecvt< _CharT, char, _State > &__cvt)

constexpr size_t	__sv_check (size_t __size, size_t __pos, const char *__s)

constexpr size_t	__sv_limit (size_t __size, size_t __pos, size_t __off) noexcept

void	__terminate () noexcept

void	__throw_bad_alloc (void)

void	__throw_bad_any_cast ()

void	__throw_bad_array_new_length (void)

void	__throw_bad_cast (void)

void	__throw_bad_exception (void)

void	__throw_bad_function_call ()

void	__throw_bad_optional_access ()

void	__throw_bad_typeid (void)

void	__throw_bad_variant_access (bool __valueless)

void	__throw_bad_variant_access (const char *__what)

void	__throw_bad_weak_ptr ()

void	__throw_domain_error (const char *)

void	__throw_future_error (int)

void	__throw_invalid_argument (const char *)

void	__throw_ios_failure (const char *)

void	__throw_ios_failure (const char *, int)

void	__throw_length_error (const char *)

void	__throw_logic_error (const char *)

void	__throw_out_of_range (const char *)

void	__throw_out_of_range_fmt (const char *,...)

void	__throw_overflow_error (const char *)

void	__throw_range_error (const char *)

void	__throw_runtime_error (const char *)

void	__throw_system_error (int)

void	__throw_underflow_error (const char *)

template<typename _Tp >
constexpr _Tp *	__to_address (_Tp *__ptr) noexcept

template<typename _Ptr >
constexpr auto	__to_address (const _Ptr &__ptr) noexcept -> decltype(std::pointer_traits< _Ptr >::to_address(__ptr))

template<typename _Ptr , typename... _None>
constexpr auto	__to_address (const _Ptr &__ptr, _None...) noexcept

template<bool _Move = false, typename _Tp , size_t... _Idx>
constexpr array< remove_cv_t< _Tp >, sizeof...(_Idx)>	__to_array (_Tp(&__a)[sizeof...(_Idx)], index_sequence< _Idx... >)

template<typename _Tp >
__detail::__integer_to_chars_result_type< _Tp >	__to_chars_i (char __first, char __last, _Tp __value, int __base=10)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename _Tp >
_Tp *	__valarray_get_storage (size_t)

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

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

void	__valarray_release_memory (void *__p)

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

template<template< typename > class _Trait, typename _Tp , typename _Up = _Tp>
constexpr _Up	__value_or (_Up __def=_Up()) noexcept

template<typename... _Types, typename _Tp >
constexpr decltype(auto)	__variant_cast (_Tp &&__rhs)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename _T1 >
void	_Construct_novalue (_T1 *__p)

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

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

template<typename _ForwardIterator , typename _Size >
constexpr _ForwardIterator	_Destroy_n (_ForwardIterator __first, _Size __count)

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

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

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

_Rb_tree_node_base *	_Rb_tree_decrement (_Rb_tree_node_base *__x) throw ()

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

_Rb_tree_node_base *	_Rb_tree_increment (_Rb_tree_node_base *__x) throw ()

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

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

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

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

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

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

constexpr double	abs (double __x)

constexpr float	abs (float __x)

long	abs (long __i)

constexpr long double	abs (long double __x)

long long	abs (long long __x)

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

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

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

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

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

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

constexpr float	acos (float __x)

constexpr long double	acos (long double __x)

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

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

template<typename _Tp >
const _Tp *	addressof (const _Tp &&)=delete

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

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

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

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

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

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

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

template<typename _CharT , typename _Distance >
__gnu_cxx::__enable_if< __is_char< _CharT >::__value, void >::__type	advance (istreambuf_iterator< _CharT > &__i, _Distance __n)

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

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

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

template<typename _ValueType >
_ValueType	any_cast (const any &__any)

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

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

template<typename _Fn , typename _Tuple >
constexpr decltype(auto)	apply (_Fn &&__f, _Tuple &&__t) noexcept(__unpack_std_tuple< is_nothrow_invocable, _Fn, _Tuple >)

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

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

template<typename _Tp , typename... _Up>
	array (_Tp, _Up...) -> array< enable_if_t<(is_same_v< _Tp, _Up > &&...), _Tp >, 1+sizeof...(_Up)>

template<typename _Type , size_t _Extent>
span< const byte, _Extent==dynamic_extent ? dynamic_extent :_Extent *sizeof(_Type)>	as_bytes (span< _Type, _Extent > __sp) noexcept

template<typename _Tp >
constexpr add_const_t< _Tp > &	as_const (_Tp &__t) noexcept

template<typename _Tp >
void	as_const (const _Tp &&)=delete

template<typename _Type , size_t _Extent> requires (!is_const_v<_Type>)
span< byte, _Extent==dynamic_extent ? dynamic_extent :_Extent *sizeof(_Type)>	as_writable_bytes (span< _Type, _Extent > __sp) noexcept

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

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

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

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

constexpr float	asin (float __x)

constexpr long double	asin (long double __x)

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

template<typename _Tp >
__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)

template<typename _Tp >
__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)

template<size_t _Align, class _Tp >
constexpr _Tp *	assume_aligned (_Tp *__ptr) noexcept

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

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

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

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

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

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

constexpr float	atan (float __x)

constexpr long double	atan (long double __x)

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

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

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

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

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

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

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

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

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

constexpr float	atan2 (float __y, float __x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void	atomic_flag_clear (atomic_flag *__a) noexcept

void	atomic_flag_clear (volatile atomic_flag *__a) noexcept

void	atomic_flag_clear_explicit (atomic_flag *__a, memory_order __m) noexcept

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

bool	atomic_flag_test_and_set (atomic_flag *__a) noexcept

bool	atomic_flag_test_and_set (volatile atomic_flag *__a) noexcept

bool	atomic_flag_test_and_set_explicit (atomic_flag *__a, memory_order __m) noexcept

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

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

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

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

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

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

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

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

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

template<typename _Tp >
void	atomic_notify_all (atomic< _Tp > *__a) noexcept

template<typename _Tp >
void	atomic_notify_one (atomic< _Tp > *__a) noexcept

void	atomic_signal_fence (memory_order __m) noexcept

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

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

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

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

void	atomic_thread_fence (memory_order __m) noexcept

template<typename _Tp >
void	atomic_wait (const atomic< _Tp > *__a, typename std::atomic< _Tp >::value_type __old) noexcept

template<typename _Tp >
void	atomic_wait_explicit (const atomic< _Tp > *__a, typename std::atomic< _Tp >::value_type __old, std::memory_order __m) noexcept

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

template<typename _ForwardIterator >
	basic_regex (_ForwardIterator, _ForwardIterator, regex_constants::syntax_option_type={}) -> basic_regex< typename iterator_traits< _ForwardIterator >::value_type >

template<typename _InputIterator , typename _CharT = typename iterator_traits<_InputIterator>::value_type, typename _Allocator = allocator<_CharT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>>
	basic_string (_InputIterator, _InputIterator, _Allocator=_Allocator()) -> basic_string< _CharT, char_traits< _CharT >, _Allocator >

template<typename _CharT , typename _Traits , typename _Allocator = allocator<_CharT>, typename = _RequireAllocator<_Allocator>>
	basic_string (basic_string_view< _CharT, _Traits >, const _Allocator &=_Allocator()) -> basic_string< _CharT, _Traits, _Allocator >

template<typename _CharT , typename _Traits , typename _Allocator = allocator<_CharT>, typename = _RequireAllocator<_Allocator>>
	basic_string (basic_string_view< _CharT, _Traits >, typename basic_string< _CharT, _Traits, _Allocator >::size_type, typename basic_string< _CharT, _Traits, _Allocator >::size_type, const _Allocator &=_Allocator()) -> basic_string< _CharT, _Traits, _Allocator >

template<contiguous_iterator _It, sized_sentinel_for< _It > _End>
	basic_string_view (_It, _End) -> basic_string_view< iter_value_t< _It > >

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

template<typename _Tp , size_t _Nm>
constexpr _Tp *	begin (_Tp(&__arr)[_Nm]) noexcept

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

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

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

template<typename _Tpa , typename _Tpb >
__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)

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

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

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

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

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

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

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

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

template<typename _Fn , typename... _Args>
constexpr _Bind_front_t< _Fn, _Args... >	bind_front (_Fn &&__fn, _Args &&... __args) noexcept(is_nothrow_constructible_v< _Bind_front_t< _Fn, _Args... >, int, _Fn, _Args... >)

template<typename _To , typename _From > requires (sizeof(_To) == sizeof(_From)) && __is_trivially_copyable(_To) && __is_trivially_copyable(_From)
constexpr _To	bit_cast (const _From &__from) noexcept

template<typename _Tp >
constexpr _If_is_unsigned_integer< _Tp >	bit_ceil (_Tp __x) noexcept

template<typename _Tp >
constexpr _If_is_unsigned_integer< _Tp >	bit_floor (_Tp __x) noexcept

template<typename _Tp >
constexpr _If_is_unsigned_integer< _Tp >	bit_width (_Tp __x) noexcept

ios_base &	boolalpha (ios_base &__base)

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

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

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

constexpr float	ceil (float __x)

constexpr long double	ceil (long double __x)

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

template<typename _Tp >
constexpr const _Tp &	clamp (const _Tp &__val, const _Tp &__lo, const _Tp &__hi)

template<typename _Tp , typename _Compare >
constexpr const _Tp &	clamp (const _Tp &__val, const _Tp &__lo, const _Tp &__hi, _Compare __comp)

template<typename _Tp , typename _Up >
constexpr bool	cmp_equal (_Tp __t, _Up __u) noexcept

template<typename _Tp , typename _Up >
constexpr bool	cmp_greater (_Tp __t, _Up __u) noexcept

template<typename _Tp , typename _Up >
constexpr bool	cmp_greater_equal (_Tp __t, _Up __u) noexcept

template<typename _Tp , typename _Up >
constexpr bool	cmp_less (_Tp __t, _Up __u) noexcept

template<typename _Tp , typename _Up >
constexpr bool	cmp_less_equal (_Tp __t, _Up __u) noexcept

template<typename _Tp , typename _Up >
constexpr bool	cmp_not_equal (_Tp __t, _Up __u) noexcept

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

float	comp_ellint_1f (float __k)

long double	comp_ellint_1l (long double __k)

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

float	comp_ellint_2f (float __k)

long double	comp_ellint_2l (long double __k)

template<typename _Tp , typename _Tpn >
__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)

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

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

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

template<typename _Tp , typename... _Args>
constexpr auto	construct_at (_Tp __location, _Args &&... __args) noexcept(noexcept(::new((void ) 0) _Tp(std::declval< _Args >()...))) -> decltype(::new((void *) 0) _Tp(std::declval< _Args >()...))

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

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

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

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

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

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

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

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

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

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

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

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

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

constexpr float	cos (float __x)

constexpr long double	cos (long double __x)

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

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

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

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

constexpr float	cosh (float __x)

constexpr long double	cosh (long double __x)

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

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

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

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

template<typename _Tp >
constexpr _If_is_unsigned_integer< _Tp, int >	countl_one (_Tp __x) noexcept

template<typename _Tp >
constexpr _If_is_unsigned_integer< _Tp, int >	countl_zero (_Tp __x) noexcept

template<typename _Tp >
constexpr _If_is_unsigned_integer< _Tp, int >	countr_one (_Tp __x) noexcept

template<typename _Tp >
constexpr _If_is_unsigned_integer< _Tp, int >	countr_zero (_Tp __x) noexcept

template<typename _Container >
constexpr auto	crbegin (const _Container &__cont) -> decltype(std::rbegin(__cont))

template<typename _Container >
constexpr auto	crend (const _Container &__cont) -> decltype(std::rend(__cont))

exception_ptr	current_exception () noexcept

template<typename _Tpnu , typename _Tp >
__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)

template<typename _Tpnu , typename _Tp >
__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)

template<typename _Tpnu , typename _Tp >
__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)

template<typename _Tpnu , typename _Tp >
__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)

template<typename _Container >
constexpr auto	data (_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())

template<typename _Tp , size_t _Nm>
constexpr _Tp *	data (_Tp(&__array)[_Nm]) noexcept

template<typename _Container >
constexpr auto	data (const _Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())

template<typename _Tp >
constexpr const _Tp *	data (initializer_list< _Tp > __il) noexcept

ios_base &	dec (ios_base &__base)

void	declare_no_pointers (char *, size_t)

void	declare_reachable (void *)

template<typename _Tp >
auto	declval () noexcept -> decltype(__declval< _Tp >(0))

ios_base &	defaultfloat (ios_base &__base)

template<typename _InputIterator , typename _ValT = typename iterator_traits<_InputIterator>::value_type, typename _Allocator = allocator<_ValT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>>
	deque (_InputIterator, _InputIterator, _Allocator=_Allocator()) -> deque< _ValT, _Allocator >

template<typename _ForwardIterator >
constexpr void	destroy (_ForwardIterator __first, _ForwardIterator __last)

template<typename _Tp >
constexpr void	destroy_at (_Tp *__location)

template<typename _ForwardIterator , typename _Size >
constexpr _ForwardIterator	destroy_n (_ForwardIterator __first, _Size __count)

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

ldiv_t	div (long __i, long __j) noexcept

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

template<typename _Tp , typename _Tpp >
__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)

template<typename _Tp , typename _Tpp >
__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)

template<typename _Tp , typename _Tpn , typename _Tpp >
__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)

template<typename _Container >
constexpr auto	empty (const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())

template<typename _Tp , size_t _Nm>
constexpr bool	empty (const _Tp(&)[_Nm]) noexcept

template<typename _Tp >
constexpr bool	empty (initializer_list< _Tp > __il) noexcept

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

template<typename _Tp , size_t _Nm>
constexpr _Tp *	end (_Tp(&__arr)[_Nm]) noexcept

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename _CharT , typename _Traits , typename _Alloc , typename _Up >
constexpr basic_string< _CharT, _Traits, _Alloc >::size_type	erase (basic_string< _CharT, _Traits, _Alloc > &__cont, const _Up &__value)

template<typename _Tp , typename _Alloc , typename _Up >
deque< _Tp, _Alloc >::size_type	erase (deque< _Tp, _Alloc > &__cont, const _Up &__value)

template<typename _Tp , typename _Alloc , typename _Up >
forward_list< _Tp, _Alloc >::size_type	erase (forward_list< _Tp, _Alloc > &__cont, const _Up &__value)

template<typename _Tp , typename _Alloc , typename _Up >
list< _Tp, _Alloc >::size_type	erase (list< _Tp, _Alloc > &__cont, const _Up &__value)

template<typename _Tp , typename _Alloc , typename _Up >
constexpr vector< _Tp, _Alloc >::size_type	erase (vector< _Tp, _Alloc > &__cont, const _Up &__value)

template<typename _CharT , typename _Traits , typename _Alloc , typename _Predicate >
constexpr basic_string< _CharT, _Traits, _Alloc >::size_type	erase_if (basic_string< _CharT, _Traits, _Alloc > &__cont, _Predicate __pred)

template<typename _Tp , typename _Alloc , typename _Predicate >
deque< _Tp, _Alloc >::size_type	erase_if (deque< _Tp, _Alloc > &__cont, _Predicate __pred)

template<typename _Tp , typename _Alloc , typename _Predicate >
forward_list< _Tp, _Alloc >::size_type	erase_if (forward_list< _Tp, _Alloc > &__cont, _Predicate __pred)

template<typename _Tp , typename _Alloc , typename _Predicate >
list< _Tp, _Alloc >::size_type	erase_if (list< _Tp, _Alloc > &__cont, _Predicate __pred)

template<typename _Key , typename _Tp , typename _Compare , typename _Alloc , typename _Predicate >
map< _Key, _Tp, _Compare, _Alloc >::size_type	erase_if (map< _Key, _Tp, _Compare, _Alloc > &__cont, _Predicate __pred)

template<typename _Key , typename _Tp , typename _Compare , typename _Alloc , typename _Predicate >
multimap< _Key, _Tp, _Compare, _Alloc >::size_type	erase_if (multimap< _Key, _Tp, _Compare, _Alloc > &__cont, _Predicate __pred)

template<typename _Key , typename _Compare , typename _Alloc , typename _Predicate >
multiset< _Key, _Compare, _Alloc >::size_type	erase_if (multiset< _Key, _Compare, _Alloc > &__cont, _Predicate __pred)

template<typename _Key , typename _Compare , typename _Alloc , typename _Predicate >
set< _Key, _Compare, _Alloc >::size_type	erase_if (set< _Key, _Compare, _Alloc > &__cont, _Predicate __pred)

template<typename _Key , typename _Tp , typename _Hash , typename _CPred , typename _Alloc , typename _Predicate >
unordered_map< _Key, _Tp, _Hash, _CPred, _Alloc >::size_type	erase_if (unordered_map< _Key, _Tp, _Hash, _CPred, _Alloc > &__cont, _Predicate __pred)

template<typename _Key , typename _Tp , typename _Hash , typename _CPred , typename _Alloc , typename _Predicate >
unordered_multimap< _Key, _Tp, _Hash, _CPred, _Alloc >::size_type	erase_if (unordered_multimap< _Key, _Tp, _Hash, _CPred, _Alloc > &__cont, _Predicate __pred)

template<typename _Key , typename _Hash , typename _CPred , typename _Alloc , typename _Predicate >
unordered_multiset< _Key, _Hash, _CPred, _Alloc >::size_type	erase_if (unordered_multiset< _Key, _Hash, _CPred, _Alloc > &__cont, _Predicate __pred)

template<typename _Key , typename _Hash , typename _CPred , typename _Alloc , typename _Predicate >
unordered_set< _Key, _Hash, _CPred, _Alloc >::size_type	erase_if (unordered_set< _Key, _Hash, _CPred, _Alloc > &__cont, _Predicate __pred)

template<typename _Tp , typename _Alloc , typename _Predicate >
constexpr vector< _Tp, _Alloc >::size_type	erase_if (vector< _Tp, _Alloc > &__cont, _Predicate __pred)

template<typename _Tp , typename _Up = _Tp>
constexpr _Tp	exchange (_Tp &__obj, _Up &&__new_val) noexcept(__and_< is_nothrow_move_constructible< _Tp >, is_nothrow_assignable< _Tp &, _Up > >::value)

template<typename _InputIterator , typename _OutputIterator , typename _Tp >
constexpr _OutputIterator	exclusive_scan (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init)

template<typename _InputIterator , typename _OutputIterator , typename _Tp , typename _BinaryOperation >
constexpr _OutputIterator	exclusive_scan (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init, _BinaryOperation __binary_op)

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

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

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

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

constexpr float	exp (float __x)

constexpr long double	exp (long double __x)

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

float	expintf (float __x)

long double	expintl (long double __x)

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

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

constexpr float	fabs (float __x)

constexpr long double	fabs (long double __x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ios_base &	fixed (ios_base &__base)

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

constexpr float	floor (float __x)

constexpr long double	floor (long double __x)

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

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

constexpr float	fmod (float __x, float __y)

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

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

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

template<typename _InputIterator , typename _Size , typename _Function >
constexpr _InputIterator	for_each_n (_InputIterator __first, _Size __n, _Function __f)

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

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

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

template<typename _InputIterator , typename _ValT = typename iterator_traits<_InputIterator>::value_type, typename _Allocator = allocator<_ValT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>>
	forward_list (_InputIterator, _InputIterator, _Allocator=_Allocator()) -> forward_list< _ValT, _Allocator >

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

float	frexp (float __x, int *__exp)

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

template<typename _Tp >
__detail::__integer_from_chars_result_type< _Tp >	from_chars (const char __first, const char __last, _Tp &__value, int __base=10)

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

template<typename _Fn , typename _Signature = __function_guide_t<_Fn, decltype(&_Fn::operator())>>
	function (_Fn) -> function< _Signature >

template<typename _Res , typename... _ArgTypes>
	function (_Res(*)(_ArgTypes...)) -> function< _Res(_ArgTypes...)>

const error_category &	future_category () noexcept

template<typename _Mn , typename _Nn >
constexpr common_type_t< _Mn, _Nn >	gcd (_Mn __m, _Nn __n) noexcept

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

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

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

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

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

const error_category &	generic_category () noexcept

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

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

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

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

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

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

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

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

template<size_t _Np, typename... _Types>
constexpr variant_alternative_t< _Np, variant< _Types... > > const &&	get (const variant< _Types... > &&)

template<typename _Tp , typename... _Types>
constexpr const _Tp &&	get (const variant< _Types... > &&__v)

template<size_t _Np, typename... _Types>
constexpr const variant_alternative_t< _Np, variant< _Types... > > &&	get (const variant< _Types... > &&__v)

template<size_t _Np, typename... _Types>
constexpr variant_alternative_t< _Np, variant< _Types... > > const &	get (const variant< _Types... > &)

template<typename _Tp , typename... _Types>
constexpr const _Tp &	get (const variant< _Types... > &__v)

template<size_t _Np, typename... _Types>
constexpr const variant_alternative_t< _Np, variant< _Types... > > &	get (const variant< _Types... > &__v)

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

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

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

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

template<size_t _Np, typename... _Types>
constexpr variant_alternative_t< _Np, variant< _Types... > > &&	get (variant< _Types... > &&)

template<typename _Tp , typename... _Types>
constexpr _Tp &&	get (variant< _Types... > &&__v)

template<size_t _Np, typename... _Types>
constexpr variant_alternative_t< _Np, variant< _Types... > > &	get (variant< _Types... > &)

template<typename _Tp , typename... _Types>
constexpr _Tp &	get (variant< _Types... > &__v)

Catalogs &	get_catalogs ()

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

template<size_t _Np, typename... _Types>
constexpr add_pointer_t< const variant_alternative_t< _Np, variant< _Types... > > >	get_if (const variant< _Types... > *__ptr) noexcept

template<typename _Tp , typename... _Types>
constexpr add_pointer_t< const _Tp >	get_if (const variant< _Types... > *__ptr) noexcept

template<size_t _Np, typename... _Types>
constexpr add_pointer_t< variant_alternative_t< _Np, variant< _Types... > > >	get_if (variant< _Types... > *__ptr) noexcept

template<typename _Tp , typename... _Types>
constexpr add_pointer_t< _Tp >	get_if (variant< _Types... > *__ptr) noexcept

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

new_handler	get_new_handler () noexcept

pointer_safety	get_pointer_safety () noexcept

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

terminate_handler	get_terminate () noexcept

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

unexpected_handler	get_unexpected () noexcept

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

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

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

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

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

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

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

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

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

template<typename _Tp >
constexpr _If_is_unsigned_integer< _Tp, bool >	has_single_bit (_Tp __x) noexcept

template<typename _Tp >
__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)

template<typename _Tp , typename... _Types>
constexpr bool	holds_alternative (const variant< _Types... > &__v) noexcept

template<typename _Tp , typename _Up , typename _Vp >
__gnu_cxx::__promoted_t< _Tp, _Up, _Vp >	hypot (_Tp __x, _Up __y, _Vp __z)

double	hypot (double __x, double __y, double __z)

float	hypot (float __x, float __y, float __z)

long double	hypot (long double __x, long double __y, long double __z)

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

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

template<typename _Up , typename _Tp >
constexpr bool	in_range (_Tp __t) noexcept

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

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

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

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

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

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

template<typename _InputIterator , typename _OutputIterator , typename _BinaryOperation , typename _Tp >
constexpr _OutputIterator	inclusive_scan (_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op, _Tp __init)

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

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

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

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

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

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

template<typename _Container >
constexpr insert_iterator< _Container >	inserter (_Container &__x, std::__detail::__range_iter_t< _Container > __i)

ios_base &	internal (ios_base &__base)

template<typename _Callable , typename... _Args>
constexpr invoke_result_t< _Callable, _Args... >	invoke (_Callable &&__fn, _Args &&... __args) noexcept(is_nothrow_invocable_v< _Callable, _Args... >)

const error_category &	iostream_category () noexcept

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

constexpr bool	is_constant_evaluated () noexcept

template<typename _S1 , typename _S2 , typename _M1 , typename _M2 >
constexpr bool	is_corresponding_member (_M1 _S1::__m1, _M2 _S2::__m2) noexcept

constexpr bool	is_eq (partial_ordering __cmp) noexcept

constexpr bool	is_gt (partial_ordering __cmp) noexcept

constexpr bool	is_gteq (partial_ordering __cmp) noexcept

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

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

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

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

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

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

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

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

constexpr bool	is_lt (partial_ordering __cmp) noexcept

constexpr bool	is_lteq (partial_ordering __cmp) noexcept

constexpr bool	is_neq (partial_ordering __cmp) noexcept

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

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

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

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

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

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

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

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

template<typename _Tp , typename _Mem >
constexpr bool	is_pointer_interconvertible_with_class (_Mem _Tp::*__mp) noexcept

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename _Tp >
__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)

template<typename _Ret , typename... _Args>
void	launder (_Ret(*)(_Args...))=delete

template<typename _Ret , typename... _Args>
void	launder (_Ret(*)(_Args......))=delete

template<typename _Tp >
constexpr _Tp *	launder (_Tp *__p) noexcept

void	launder (const void *)=delete

void	launder (const volatile void *)=delete

void	launder (void *)=delete

void	launder (volatile void *)=delete

template<typename _Mn , typename _Nn >
constexpr common_type_t< _Mn, _Nn >	lcm (_Mn __m, _Nn __n) noexcept

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

constexpr float	ldexp (float __x, int __exp)

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

ios_base &	left (ios_base &__base)

template<typename _Tp >
__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)

template<typename _Tp , typename _Up , typename _Vp >
constexpr __gnu_cxx::__promoted_t< _Tp, _Up, _Vp >	lerp (_Tp __x, _Up __y, _Vp __z) noexcept

constexpr double	lerp (double __a, double __b, double __t) noexcept

constexpr float	lerp (float __a, float __b, float __t) noexcept

constexpr long double	lerp (long double __a, long double __b, long double __t) noexcept

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

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

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

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

template<typename _InputIterator , typename _ValT = typename iterator_traits<_InputIterator>::value_type, typename _Allocator = allocator<_ValT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>>
	list (_InputIterator, _InputIterator, _Allocator=_Allocator()) -> list< _ValT, _Allocator >

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

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

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

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

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

constexpr float	log (float __x)

constexpr long double	log (long double __x)

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

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

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

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

constexpr float	log10 (float __x)

constexpr long double	log10 (long double __x)

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

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

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

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

template<typename _Tp , typename... _Args>
enable_if_t< is_constructible_v< any, in_place_type_t< _Tp >, _Args... >, any >	make_any (_Args &&... __args)

template<typename _Tp , typename _Up , typename... _Args>
enable_if_t< is_constructible_v< any, in_place_type_t< _Tp >, initializer_list< _Up > &, _Args... >, any >	make_any (initializer_list< _Up > __il, _Args &&... __args)

error_code	make_error_code (future_errc __errc) noexcept

error_code	make_error_code (io_errc __e) noexcept

error_condition	make_error_condition (future_errc __errc) noexcept

error_condition	make_error_condition (io_errc __e) noexcept

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

template<typename _Tp , typename _Tuple >
constexpr _Tp	make_from_tuple (_Tuple &&__t) noexcept(__unpack_std_tuple< is_nothrow_constructible, _Tp, _Tuple >)

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

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

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

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

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

template<typename _Tp , typename _Alloc , typename... _Args>
constexpr _Tp	make_obj_using_allocator (const _Alloc &__a, _Args &&... __args)

template<typename _Tp , typename... _Args>
constexpr enable_if_t< is_constructible_v< _Tp, _Args... >, optional< _Tp > >	make_optional (_Args &&... __args) noexcept(is_nothrow_constructible_v< _Tp, _Args... >)

template<typename _Tp >
constexpr enable_if_t< is_constructible_v< decay_t< _Tp >, _Tp >, optional< decay_t< _Tp > > >	make_optional (_Tp &&__t) noexcept(is_nothrow_constructible_v< optional< decay_t< _Tp > >, _Tp >)

template<typename _Tp , typename _Up , typename... _Args>
constexpr enable_if_t< is_constructible_v< _Tp, initializer_list< _Up > &, _Args... >, optional< _Tp > >	make_optional (initializer_list< _Up > __il, _Args &&... __args) noexcept(is_nothrow_constructible_v< _Tp, initializer_list< _Up > &, _Args... >)

template<typename _Iterator >
constexpr reverse_iterator< _Iterator >	make_reverse_iterator (_Iterator __i)

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

template<typename _InputIterator , typename _Allocator , typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>>
	map (_InputIterator, _InputIterator, _Allocator) -> map< __iter_key_t< _InputIterator >, __iter_val_t< _InputIterator >, less< __iter_key_t< _InputIterator > >, _Allocator >

template<typename _InputIterator , typename _Compare = less<__iter_key_t<_InputIterator>>, typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>>
	map (_InputIterator, _InputIterator, _Compare=_Compare(), _Allocator=_Allocator()) -> map< __iter_key_t< _InputIterator >, __iter_val_t< _InputIterator >, _Compare, _Allocator >

template<typename _Key , typename _Tp , typename _Allocator , typename = _RequireAllocator<_Allocator>>
	map (initializer_list< pair< _Key, _Tp > >, _Allocator) -> map< _Key, _Tp, less< _Key >, _Allocator >

template<typename _Key , typename _Tp , typename _Compare = less<_Key>, typename _Allocator = allocator<pair<const _Key, _Tp>>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>>
	map (initializer_list< pair< _Key, _Tp > >, _Compare=_Compare(), _Allocator=_Allocator()) -> map< _Key, _Tp, _Compare, _Allocator >

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename _Ret , typename _Tp , typename _Arg >
const_mem_fun1_ref_t< _Ret, _Tp, _Arg >	mem_fun_ref (_Ret(_Tp::*__f)(_Arg) const)

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

void *	memchr (void *__s, int __c, size_t __n)

template<typename _IIter1 , typename _IIter2 , typename _OIter >
constexpr _OIter	merge (_IIter1, _IIter1, _IIter2, _IIter2, _OIter)

template<typename _IIter1 , typename _IIter2 , typename _OIter , typename _Compare >
constexpr _OIter	merge (_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare)

template<typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator >
constexpr _OutputIterator	merge (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)

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

template<typename _Tp >
constexpr enable_if_t< is_object_v< _Tp >, _Tp * >	midpoint (_Tp __a, _Tp __b) noexcept

template<typename _Tp >
constexpr enable_if_t< __and_v< is_arithmetic< _Tp >, is_same< remove_cv_t< _Tp >, _Tp >, __not_< is_same< _Tp, bool > > >, _Tp >	midpoint (_Tp __a, _Tp __b) noexcept

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

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

template<typename _Tp >
constexpr _Tp	min (initializer_list< _Tp >)

template<typename _Tp , typename _Compare >
constexpr _Tp	min (initializer_list< _Tp >, _Compare)

template<typename _FIter >
constexpr _FIter	min_element (_FIter, _FIter)

template<typename _FIter , typename _Compare >
constexpr _FIter	min_element (_FIter, _FIter, _Compare)

template<typename _ForwardIterator >
constexpr _ForwardIterator	min_element (_ForwardIterator __first, _ForwardIterator __last)

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

template<typename _Tp >
constexpr pair< const _Tp &, const _Tp & >	minmax (const _Tp &__a, const _Tp &__b)

template<typename _Tp , typename _Compare >
constexpr pair< const _Tp &, const _Tp & >	minmax (const _Tp &__a, const _Tp &__b, _Compare __comp)

template<typename _Tp >
constexpr pair< _Tp, _Tp >	minmax (initializer_list< _Tp >)

template<typename _Tp , typename _Compare >
constexpr pair< _Tp, _Tp >	minmax (initializer_list< _Tp >, _Compare)

template<typename _FIter >
constexpr pair< _FIter, _FIter >	minmax_element (_FIter, _FIter)

template<typename _FIter , typename _Compare >
constexpr pair< _FIter, _FIter >	minmax_element (_FIter, _FIter, _Compare)

template<typename _ForwardIterator >
constexpr pair< _ForwardIterator, _ForwardIterator >	minmax_element (_ForwardIterator __first, _ForwardIterator __last)

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

template<typename _IIter1 , typename _IIter2 >
constexpr pair< _IIter1, _IIter2 >	mismatch (_IIter1, _IIter1, _IIter2)

template<typename _IIter1 , typename _IIter2 , typename _BinaryPredicate >
constexpr pair< _IIter1, _IIter2 >	mismatch (_IIter1, _IIter1, _IIter2, _BinaryPredicate)

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

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

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

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

float	modf (float __x, float *__iptr)

long double	modf (long double __x, long double *__iptr)

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

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

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

template<typename _Tp >
constexpr __conditional_t< __move_if_noexcept_cond< _Tp >::value, const _Tp &, _Tp && >	move_if_noexcept (_Tp &__x) noexcept

template<typename _InputIterator , typename _Allocator , typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>>
	multimap (_InputIterator, _InputIterator, _Allocator) -> multimap< __iter_key_t< _InputIterator >, __iter_val_t< _InputIterator >, less< __iter_key_t< _InputIterator > >, _Allocator >

template<typename _InputIterator , typename _Compare = less<__iter_key_t<_InputIterator>>, typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>>
	multimap (_InputIterator, _InputIterator, _Compare=_Compare(), _Allocator=_Allocator()) -> multimap< __iter_key_t< _InputIterator >, __iter_val_t< _InputIterator >, _Compare, _Allocator >

template<typename _Key , typename _Tp , typename _Allocator , typename = _RequireAllocator<_Allocator>>
	multimap (initializer_list< pair< _Key, _Tp > >, _Allocator) -> multimap< _Key, _Tp, less< _Key >, _Allocator >

template<typename _Key , typename _Tp , typename _Compare = less<_Key>, typename _Allocator = allocator<pair<const _Key, _Tp>>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>>
	multimap (initializer_list< pair< _Key, _Tp > >, _Compare=_Compare(), _Allocator=_Allocator()) -> multimap< _Key, _Tp, _Compare, _Allocator >

template<typename _InputIterator , typename _Allocator , typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>>
	multiset (_InputIterator, _InputIterator, _Allocator) -> multiset< typename iterator_traits< _InputIterator >::value_type, less< typename iterator_traits< _InputIterator >::value_type >, _Allocator >

template<typename _InputIterator , typename _Compare = less<typename iterator_traits<_InputIterator>::value_type>, typename _Allocator = allocator<typename iterator_traits<_InputIterator>::value_type>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>>
	multiset (_InputIterator, _InputIterator, _Compare=_Compare(), _Allocator=_Allocator()) -> multiset< typename iterator_traits< _InputIterator >::value_type, _Compare, _Allocator >

template<typename _Key , typename _Allocator , typename = _RequireAllocator<_Allocator>>
	multiset (initializer_list< _Key >, _Allocator) -> multiset< _Key, less< _Key >, _Allocator >

template<typename _Key , typename _Compare = less<_Key>, typename _Allocator = allocator<_Key>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>>
	multiset (initializer_list< _Key >, _Compare=_Compare(), _Allocator=_Allocator()) -> multiset< _Key, _Compare, _Allocator >

template<typename _InputIterator >
constexpr _InputIterator	next (_InputIterator __x, typename iterator_traits< _InputIterator >::difference_type __n=1)

template<typename _BidirectionalIterator >
constexpr bool	next_permutation (_BidirectionalIterator __first, _BidirectionalIterator __last)

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

template<typename _BIter >
constexpr bool	next_permutation (_BIter, _BIter)

template<typename _BIter , typename _Compare >
constexpr bool	next_permutation (_BIter, _BIter, _Compare)

ios_base &	noboolalpha (ios_base &__base)

template<typename _IIter , typename _Predicate >
constexpr bool	none_of (_IIter, _IIter, _Predicate)

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

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

template<typename _Tp >
_Tp constexpr	norm (const complex< _Tp > &)

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

ios_base &	noshowbase (ios_base &__base)

ios_base &	noshowpoint (ios_base &__base)

ios_base &	noshowpos (ios_base &__base)

ios_base &	noskipws (ios_base &__base)

template<typename _Predicate >
constexpr unary_negate< _Predicate >	not1 (const _Predicate &__pred)

template<typename _Predicate >
constexpr binary_negate< _Predicate >	not2 (const _Predicate &__pred)

template<typename _Fn >
constexpr auto	not_fn (_Fn &&__fn) noexcept(std::is_nothrow_constructible< std::decay_t< _Fn >, _Fn && >::value)

void	notify_all_at_thread_exit (condition_variable &, unique_lock< mutex >)

ios_base &	nounitbuf (ios_base &__base)

ios_base &	nouppercase (ios_base &__base)

template<typename _RAIter >
constexpr void	nth_element (_RAIter, _RAIter, _RAIter)

template<typename _RAIter , typename _Compare >
constexpr void	nth_element (_RAIter, _RAIter, _RAIter, _Compare)

template<typename _RandomAccessIterator >
constexpr void	nth_element (_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last)

template<typename _RandomAccessIterator , typename _Compare >
constexpr void	nth_element (_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)

ios_base &	oct (ios_base &__base)

template<typename _CharT , typename _Traits >
constexpr bool	operator!= (__type_identity_t< basic_string_view< _CharT, _Traits > > __x, basic_string_view< _CharT, _Traits > __y) noexcept

template<typename _CharT , typename _Traits >
constexpr bool	operator!= (basic_string_view< _CharT, _Traits > __x, __type_identity_t< basic_string_view< _CharT, _Traits > > __y) noexcept

template<typename _CharT , typename _Traits >
constexpr bool	operator!= (basic_string_view< _CharT, _Traits > __x, basic_string_view< _CharT, _Traits > __y) noexcept

template<typename _Tp , _Lock_policy _Lp>
bool	operator!= (const __shared_ptr< _Tp, _Lp > &__a, nullptr_t) noexcept

template<typename _Tp1 , typename _Tp2 , _Lock_policy _Lp>
bool	operator!= (const __shared_ptr< _Tp1, _Lp > &__a, const __shared_ptr< _Tp2, _Lp > &__b) noexcept

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

template<class _Dom >
_Expr< _BinClos< struct std::__not_equal_to, _Expr, _ValArray, _Dom, typename _Dom::value_type >, typename __fun< struct std::__not_equal_to, typename _Dom::value_type >::result_type >	operator!= (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< struct std::__not_equal_to, _Expr, _Constant, _Dom, typename _Dom::value_type >, typename __fun< struct std::__not_equal_to, typename _Dom::value_type >::result_type >	operator!= (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< struct std::__not_equal_to, _Expr, _Expr, _Dom1, _Dom2 >, typename __fun< struct std::__not_equal_to, typename _Dom1::value_type >::result_type >	operator!= (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<typename _Tp , typename _Up >
constexpr auto	operator!= (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_ne_t< _Up, _Tp >

template<typename _Tp , std::size_t _Nm>
constexpr bool	operator!= (const array< _Tp, _Nm > &__one, const array< _Tp, _Nm > &__two)

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

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

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

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

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

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

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

template<typename _Iterator >
constexpr bool	operator!= (const move_iterator< _Iterator > &__x, const move_iterator< _Iterator > &__y)

template<typename _IteratorL , typename _IteratorR >
constexpr bool	operator!= (const move_iterator< _IteratorL > &__x, const move_iterator< _IteratorR > &__y)

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

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

template<typename _Tp , typename _Up >
constexpr auto	operator!= (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_ne_t< _Tp, _Up >

template<typename _Tp , typename _Up >
constexpr auto	operator!= (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_ne_t< _Tp, _Up >

template<typename _Tp >
constexpr bool	operator!= (const optional< _Tp > &__lhs, nullopt_t) noexcept

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

template<typename _IteratorL , typename _IteratorR > requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
constexpr bool	operator!= (const reverse_iterator< _IteratorL > &__x, const reverse_iterator< _IteratorR > &__y)

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

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

bool	operator!= (const std::bernoulli_distribution &__d1, const std::bernoulli_distribution &__d2)

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename _UIntType , size_t __w, size_t __n, size_t __m, size_t __r, _UIntType __a, size_t __u, _UIntType __d, size_t __s, _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
bool	operator!= (const std::mersenne_twister_engine< _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f > &__lhs, const std::mersenne_twister_engine< _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f > &__rhs)

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

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

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

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

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

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

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

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

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

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

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

template<typename... _TElements, typename... _UElements>
constexpr bool	operator!= (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)

template<class _Dom >
_Expr< _BinClos< struct std::__not_equal_to, _Constant, _Expr, typename _Dom::value_type, _Dom >, typename __fun< struct std::__not_equal_to, typename _Dom::value_type >::result_type >	operator!= (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<typename _Tp >
_Expr< _BinClos< __not_equal_to, _Constant, _ValArray, _Tp, _Tp >, typename __fun< __not_equal_to, _Tp >::result_type >	operator!= (const typename valarray< _Tp >::value_type &__t, const valarray< _Tp > &__v)

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool	operator!= (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _Tp , typename _Dp >
bool	operator!= (const unique_ptr< _Tp, _Dp > &__x, nullptr_t) noexcept

template<typename _Tp >
_Expr< _BinClos< __not_equal_to, _ValArray, _Constant, _Tp, _Tp >, typename __fun< __not_equal_to, _Tp >::result_type >	operator!= (const valarray< _Tp > &__v, const typename valarray< _Tp >::value_type &__t)

template<typename _Tp >
_Expr< _BinClos< __not_equal_to, _ValArray, _ValArray, _Tp, _Tp >, typename __fun< __not_equal_to, _Tp >::result_type >	operator!= (const valarray< _Tp > &__v, const valarray< _Tp > &__w)

template<class _Dom >
_Expr< _BinClos< struct std::__not_equal_to, _ValArray, _Expr, typename _Dom::value_type, _Dom >, typename __fun< struct std::__not_equal_to, typename _Dom::value_type >::result_type >	operator!= (const valarray< typename _Dom::value_type > &__v, const _Expr< _Dom, typename _Dom::value_type > &__e)

template<typename... _Types>
constexpr bool	operator!= (const variant< _Types... > &__lhs, const variant< _Types... > &__rhs)

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

constexpr bool	operator!= (monostate, monostate) noexcept

template<typename _Tp >
constexpr bool	operator!= (nullopt_t, const optional< _Tp > &__rhs) noexcept

template<typename _Tp , _Lock_policy _Lp>
bool	operator!= (nullptr_t, const __shared_ptr< _Tp, _Lp > &__a) noexcept

template<typename _Tp , typename _Dp >
bool	operator!= (nullptr_t, const unique_ptr< _Tp, _Dp > &__x) noexcept

template<class _Dom >
_Expr< _BinClos< struct std::__modulus, _Expr, _ValArray, _Dom, typename _Dom::value_type >, typename __fun< struct std::__modulus, typename _Dom::value_type >::result_type >	operator% (const _Expr< _Dom, typename _Dom::value_type > &__e, const valarray< typename _Dom::value_type > &__v)

template<class _Dom >
_Expr< _BinClos< struct std::__modulus, _Expr, _Constant, _Dom, typename _Dom::value_type >, typename __fun< struct std::__modulus, typename _Dom::value_type >::result_type >	operator% (const _Expr< _Dom, typename _Dom::value_type > &__v, const typename _Dom::value_type &__t)

template<class _Dom1 , class _Dom2 >
_Expr< _BinClos< struct std::__modulus, _Expr, _Expr, _Dom1, _Dom2 >, typename __fun< struct std::__modulus, typename _Dom1::value_type >::result_type >	operator% (const _Expr< _Dom1, typename _Dom1::value_type > &__v, const _Expr< _Dom2, typename _Dom2::value_type > &__w)

template<class _Dom >
_Expr< _BinClos< struct std::__modulus, _Constant, _Expr, typename _Dom::value_type, _Dom >, typename __fun< struct std::__modulus, typename _Dom::value_type >::result_type >	operator% (const typename _Dom::value_type &__t, const _Expr< _Dom, typename _Dom::value_type > &__v)

template<typename _Tp >
_Expr<

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions