libstdc++
GNU C++ library
std Namespace Reference

Namespaces

 __atomic_impl
 
 __cmp_alg
 
 __cmp_cat
 
 __cmp_cust
 
 __cxx11
 
 __debug
 
 __detail
 
 __exception_ptr
 
 __parallel
 
 __parse_int
 
 __select_int
 
 _V2
 
 chrono
 
 decimal
 
 execution
 
 experimental
 
 filesystem
 
 literals
 
 numbers
 
 placeholders
 
 pmr
 
 ranges
 
 regex_constants
 
 rel_ops
 
 this_thread
 
 tr1
 
 tr2
 

Classes

struct  __add_lvalue_reference_helper
 
struct  __add_lvalue_reference_helper< _Tp, true >
 
struct  __add_pointer_helper
 
struct  __add_pointer_helper< _Tp, true >
 
struct  __add_rvalue_reference_helper
 
struct  __add_rvalue_reference_helper< _Tp, true >
 
struct  __aligned_storage_msa
 
struct  __alloc_neq
 
struct  __alloc_neq< _Alloc, false >
 
struct  __alloc_swap
 
struct  __alloc_swap< _Alloc, false >
 
struct  __allocated_ptr
 
struct  __allocator_traits_base
 
struct  __are_same
 
struct  __are_same< _Tp, _Tp >
 
struct  __array_traits
 
struct  __array_traits< _Tp, 0 >
 
struct  __at_thread_exit_elt
 
struct  __atomic_base
 
struct  __atomic_base< _PTp * >
 
struct  __atomic_flag_base
 
struct  __atomic_float
 
class  __atomic_futex_unsigned
 
struct  __atomic_futex_unsigned_base
 
struct  __atomic_ref
 
struct  __atomic_ref< _Fp, false, true >
 
struct  __atomic_ref< _Tp *, false, false >
 
struct  __atomic_ref< _Tp, false, false >
 
struct  __atomic_ref< _Tp, true, false >
 
struct  __atomic_semaphore
 
class  __basic_file
 
class  __basic_file< char >
 
class  __basic_future
 
struct  __bitwise_and
 
struct  __bitwise_not
 
struct  __bitwise_or
 
struct  __bitwise_xor
 
struct  __boyer_moore_array_base
 
struct  __boyer_moore_map_base
 
struct  __byte_operand
 
struct  __byte_operand< bool >
 
struct  __byte_operand< char >
 
struct  __byte_operand< char16_t >
 
struct  __byte_operand< char32_t >
 
struct  __byte_operand< const _IntegerType >
 
struct  __byte_operand< const volatile _IntegerType >
 
struct  __byte_operand< int >
 
struct  __byte_operand< long >
 
struct  __byte_operand< long long >
 
struct  __byte_operand< short >
 
struct  __byte_operand< signed char >
 
struct  __byte_operand< unsigned char >
 
struct  __byte_operand< unsigned int >
 
struct  __byte_operand< unsigned long >
 
struct  __byte_operand< unsigned long long >
 
struct  __byte_operand< unsigned short >
 
struct  __byte_operand< volatile _IntegerType >
 
struct  __byte_operand< wchar_t >
 
class  __codecvt_abstract_base
 
class  __codecvt_utf16_base
 
class  __codecvt_utf16_base< char16_t >
 
class  __codecvt_utf16_base< char32_t >
 
class  __codecvt_utf16_base< wchar_t >
 
class  __codecvt_utf8_base
 
class  __codecvt_utf8_base< char16_t >
 
class  __codecvt_utf8_base< char32_t >
 
class  __codecvt_utf8_base< wchar_t >
 
class  __codecvt_utf8_utf16_base
 
class  __codecvt_utf8_utf16_base< char16_t >
 
class  __codecvt_utf8_utf16_base< char32_t >
 
class  __codecvt_utf8_utf16_base< wchar_t >
 
struct  __combine_tuples
 
struct  __combine_tuples< tuple< _T1s... >, tuple< _T2s... >, _Rem... >
 
struct  __combine_tuples< tuple< _Ts... > >
 
struct  __combine_tuples<>
 
class  __condvar
 
struct  __copy_move
 
struct  __copy_move< _IsMove, true, random_access_iterator_tag >
 
struct  __copy_move< false, false, random_access_iterator_tag >
 
struct  __copy_move< true, false, _Category >
 
struct  __copy_move< true, false, random_access_iterator_tag >
 
struct  __copy_move_backward
 
struct  __copy_move_backward< _IsMove, true, random_access_iterator_tag >
 
struct  __copy_move_backward< false, false, random_access_iterator_tag >
 
struct  __copy_move_backward< true, false, _Category >
 
struct  __copy_move_backward< true, false, random_access_iterator_tag >
 
struct  __cow_string
 
class  __ctype_abstract_base
 
struct  __denorm_min
 
struct  __denorm_min_impl
 
struct  __digits
 
struct  __digits10
 
struct  __digits10_impl
 
struct  __digits10_impl< _Tp, true >
 
struct  __digits10_impl< double, true >
 
struct  __digits10_impl< float, true >
 
struct  __digits10_impl< long double, true >
 
struct  __digits_impl
 
struct  __digits_impl< _Tp, true >
 
struct  __digits_impl< double, true >
 
struct  __digits_impl< float, true >
 
struct  __digits_impl< long double, true >
 
struct  __divides
 
struct  __do_is_implicitly_default_constructible_impl
 
struct  __do_make_tuple
 
struct  __empty_completion
 
class  __enable_shared_from_this
 
struct  __epsilon
 
struct  __epsilon_impl
 
struct  __epsilon_impl< double >
 
struct  __epsilon_impl< float >
 
struct  __epsilon_impl< long double >
 
struct  __equal
 
struct  __equal< true >
 
struct  __equal_to
 
struct  __erased_type
 
struct  __false_type
 
struct  __finite_max
 
struct  __finite_max_impl
 
struct  __finite_max_impl< _Tp, true >
 
struct  __finite_max_impl< double, true >
 
struct  __finite_max_impl< float, true >
 
struct  __finite_max_impl< long double, true >
 
struct  __finite_min
 
struct  __finite_min_impl
 
struct  __finite_min_impl< _Tp, true >
 
struct  __finite_min_impl< double, true >
 
struct  __finite_min_impl< float, true >
 
struct  __finite_min_impl< long double, true >
 
struct  __fun
 
struct  __fun< __equal_to, _Tp >
 
struct  __fun< __greater, _Tp >
 
struct  __fun< __greater_equal, _Tp >
 
struct  __fun< __less, _Tp >
 
struct  __fun< __less_equal, _Tp >
 
struct  __fun< __logical_and, _Tp >
 
struct  __fun< __logical_not, _Tp >
 
struct  __fun< __logical_or, _Tp >
 
struct  __fun< __not_equal_to, _Tp >
 
struct  __fun_with_valarray
 
struct  __fun_with_valarray< _Tp, false >
 
struct  __function_guide_helper
 
struct  __function_guide_helper< _Res(_Tp::*)(_Args...) &noexcept(_Nx) >
 
struct  __function_guide_helper< _Res(_Tp::*)(_Args...) const &noexcept(_Nx) >
 
struct  __function_guide_helper< _Res(_Tp::*)(_Args...) const noexcept(_Nx) >
 
struct  __function_guide_helper< _Res(_Tp::*)(_Args...) noexcept(_Nx) >
 
struct  __future_base
 
struct  __get_first_arg
 
struct  __get_first_arg< _Template< _Tp, _Types... > >
 
struct  __greater
 
struct  __greater_equal
 
struct  __has_iec559_behavior
 
struct  __has_iec559_storage_format
 
struct  __has_is_transparent
 
struct  __has_is_transparent< _Func, _SfinaeType, __void_t< typename _Func::is_transparent > >
 
struct  __hash_base
 
struct  __hash_enum
 
struct  __hash_enum< _Tp, true >
 
struct  __hash_string_base
 
struct  __infinity
 
struct  __infinity_impl
 
struct  __is_alloc_insertable_impl
 
struct  __is_alloc_insertable_impl< _Alloc, _Tp, _ValueT, __void_t< decltype(allocator_traits< _Alloc >::construct(std::declval< _Alloc & >(), std::declval< _ValueT * >(), std::declval< _Tp >()))> >
 
struct  __is_allocator
 
struct  __is_allocator< _Alloc, __void_t< typename _Alloc::value_type, decltype(std::declval< _Alloc & >().allocate(size_t{}))> >
 
struct  __is_arithmetic
 
struct  __is_bitwise_relocatable<::deque< _Tp > >
 
struct  __is_byte
 
struct  __is_byte< byte >
 
struct  __is_byte< char >
 
struct  __is_byte< signed char >
 
struct  __is_byte< unsigned char >
 
struct  __is_byte_like
 
struct  __is_byte_like< _Tp, equal_to< _Tp > >
 
struct  __is_byte_like< _Tp, equal_to< void > >
 
struct  __is_byte_like< byte, equal_to< byte > >
 
struct  __is_byte_like< byte, equal_to< void > >
 
struct  __is_char
 
struct  __is_char< char >
 
struct  __is_convertible_helper
 
class  __is_convertible_helper< _From, _To, false >
 
struct  __is_copy_assignable_impl
 
struct  __is_copy_assignable_impl< _Tp, false >
 
struct  __is_copy_assignable_impl< _Tp, true >
 
struct  __is_copy_insertable
 
struct  __is_copy_insertable< allocator< _Tp > >
 
struct  __is_empty_non_tuple
 
struct  __is_empty_non_tuple< tuple< _El0, _El... > >
 
struct  __is_fast_hash
 
struct  __is_fast_hash< hash< __gnu_debug::basic_string< _CharT > > >
 
struct  __is_fast_hash< hash< experimental::string_view > >
 
struct  __is_fast_hash< hash< experimental::u16string_view > >
 
struct  __is_fast_hash< hash< experimental::u32string_view > >
 
struct  __is_fast_hash< hash< experimental::wstring_view > >
 
struct  __is_fast_hash< hash< long double > >
 
struct  __is_fast_hash< hash< optional< _Tp > > >
 
struct  __is_fast_hash< hash< string > >
 
struct  __is_fast_hash< hash< string_view > >
 
struct  __is_fast_hash< hash< u16string > >
 
struct  __is_fast_hash< hash< u16string_view > >
 
struct  __is_fast_hash< hash< u32string > >
 
struct  __is_fast_hash< hash< u32string_view > >
 
struct  __is_fast_hash< hash< variant< _Types... > > >
 
struct  __is_fast_hash< hash< wstring > >
 
struct  __is_fast_hash< hash< wstring_view > >
 
struct  __is_floating
 
struct  __is_floating< double >
 
struct  __is_floating< float >
 
struct  __is_floating< long double >
 
struct  __is_implicitly_default_constructible
 
struct  __is_implicitly_default_constructible_impl
 
struct  __is_implicitly_default_constructible_safe
 
struct  __is_in_place_type
 
struct  __is_in_place_type_impl
 
struct  __is_in_place_type_impl< in_place_type_t< _Tp > >
 
struct  __is_integer
 
struct  __is_integer< bool >
 
struct  __is_integer< char >
 
struct  __is_integer< char16_t >
 
struct  __is_integer< char32_t >
 
struct  __is_integer< int >
 
struct  __is_integer< long >
 
struct  __is_integer< long long >
 
struct  __is_integer< short >
 
struct  __is_integer< signed char >
 
struct  __is_integer< unsigned char >
 
struct  __is_integer< unsigned int >
 
struct  __is_integer< unsigned long >
 
struct  __is_integer< unsigned long long >
 
struct  __is_integer< unsigned short >
 
struct  __is_location_invariant
 
struct  __is_location_invariant< __future_base::_State_base::_Setter< _Res, _Arg > >
 
struct  __is_location_invariant< __future_base::_Task_setter< _Res_ptr, _Fn, _Res > >
 
struct  __is_member_function_pointer_helper
 
struct  __is_member_function_pointer_helper< _Tp _Cp::* >
 
struct  __is_member_object_pointer_helper
 
struct  __is_member_object_pointer_helper< _Tp _Cp::* >
 
struct  __is_memcmp_ordered
 
struct  __is_memcmp_ordered< _Tp, false >
 
struct  __is_memcmp_ordered< std::byte, false >
 
struct  __is_memcmp_ordered_with
 
struct  __is_memcmp_ordered_with< _Tp, _Up, false >
 
struct  __is_memcmp_ordered_with< _Tp, std::byte, _SameSize >
 
struct  __is_memcmp_ordered_with< std::byte, _Up, _SameSize >
 
struct  __is_memcmp_ordered_with< std::byte, std::byte, true >
 
struct  __is_move_assignable_impl
 
struct  __is_move_assignable_impl< _Tp, false >
 
struct  __is_move_assignable_impl< _Tp, true >
 
struct  __is_move_insertable
 
struct  __is_move_insertable< allocator< _Tp > >
 
struct  __is_move_iterator
 
struct  __is_move_iterator< move_iterator< _Iterator > >
 
struct  __is_move_iterator< reverse_iterator< _Iterator > >
 
struct  __is_nonvolatile_trivially_copyable
 
struct  __is_nonvolatile_trivially_copyable< volatile _Tp >
 
struct  __is_nothrow_convertible
 
struct  __is_nothrow_uses_allocator_constructible
 
struct  __is_nt_convertible_helper
 
class  __is_nt_convertible_helper< _From, _To, false >
 
struct  __is_nt_copy_assignable_impl
 
struct  __is_nt_copy_assignable_impl< _Tp, false >
 
struct  __is_nt_copy_assignable_impl< _Tp, true >
 
struct  __is_nt_move_assignable_impl
 
struct  __is_nt_move_assignable_impl< _Tp, false >
 
struct  __is_nt_move_assignable_impl< _Tp, true >
 
struct  __is_null_pointer_helper
 
struct  __is_null_pointer_helper< std::nullptr_t >
 
struct  __is_nullptr_t
 
struct  __is_pointer
 
struct  __is_pointer< _Tp * >
 
struct  __is_pointer_helper
 
struct  __is_pointer_helper< _Tp * >
 
struct  __is_random_access_iter
 
struct  __is_scalar
 
struct  __is_trivially_copy_assignable_impl
 
struct  __is_trivially_copy_assignable_impl< _Tp, false >
 
struct  __is_trivially_copy_assignable_impl< _Tp, true >
 
struct  __is_trivially_copy_constructible_impl
 
struct  __is_trivially_copy_constructible_impl< _Tp, false >
 
struct  __is_trivially_copy_constructible_impl< _Tp, true >
 
struct  __is_trivially_move_assignable_impl
 
struct  __is_trivially_move_assignable_impl< _Tp, false >
 
struct  __is_trivially_move_assignable_impl< _Tp, true >
 
struct  __is_trivially_move_constructible_impl
 
struct  __is_trivially_move_constructible_impl< _Tp, false >
 
struct  __is_trivially_move_constructible_impl< _Tp, true >
 
struct  __is_tuple_like_impl< array< _Tp, _Nm > >
 
struct  __is_tuple_like_impl< pair< _T1, _T2 > >
 
struct  __is_tuple_like_impl< tuple< _Tps... > >
 
struct  __is_uses_allocator_constructible
 
struct  __is_uses_allocator_predicate
 
struct  __is_void
 
struct  __is_void< void >
 
struct  __iterator_traits
 
struct  __iterator_traits< _Iterator, void >
 
struct  __lc_rai
 
struct  __lc_rai< random_access_iterator_tag, random_access_iterator_tag >
 
struct  __less
 
struct  __less_equal
 
struct  __lexicographical_compare
 
struct  __lexicographical_compare< true >
 
struct  __logical_and
 
struct  __logical_not
 
struct  __logical_or
 
struct  __make_1st_indices
 
struct  __make_1st_indices< _Tp, _Tpls... >
 
struct  __make_1st_indices<>
 
struct  __make_tuple
 
struct  __make_tuple_impl
 
struct  __make_tuple_impl< _Idx, tuple< _Tp... >, _Tuple, _Nm >
 
struct  __make_tuple_impl< _Nm, tuple< _Tp... >, _Tuple, _Nm >
 
struct  __max_digits10
 
struct  __max_digits10_impl
 
struct  __max_digits10_impl< _Tp, true >
 
struct  __max_exponent
 
struct  __max_exponent10
 
struct  __max_exponent10_impl
 
struct  __max_exponent10_impl< double >
 
struct  __max_exponent10_impl< float >
 
struct  __max_exponent10_impl< long double >
 
struct  __max_exponent_impl
 
struct  __max_exponent_impl< double >
 
struct  __max_exponent_impl< float >
 
struct  __max_exponent_impl< long double >
 
struct  __memcmpable
 
struct  __memcmpable< _Tp *, _Tp * >
 
struct  __memcmpable< _Tp *, const _Tp * >
 
struct  __memcmpable< const _Tp *, _Tp * >
 
struct  __memcpyable
 
struct  __memcpyable< _Tp *, _Tp * >
 
struct  __memcpyable< _Tp *, const _Tp * >
 
struct  __min_exponent
 
struct  __min_exponent10
 
struct  __min_exponent10_impl
 
struct  __min_exponent10_impl< double >
 
struct  __min_exponent10_impl< float >
 
struct  __min_exponent10_impl< long double >
 
struct  __min_exponent_impl
 
struct  __min_exponent_impl< double >
 
struct  __min_exponent_impl< float >
 
struct  __min_exponent_impl< long double >
 
struct  __minus
 
struct  __modulus
 
struct  __moneypunct_cache
 
struct  __move_if_noexcept_cond
 
struct  __multiplies
 
class  __mutex_base
 
struct  __negate
 
struct  __norm_min
 
struct  __norm_min_impl
 
struct  __norm_min_impl< _Tp, true >
 
struct  __norm_min_impl< double, true >
 
struct  __norm_min_impl< float, true >
 
struct  __norm_min_impl< long double, true >
 
struct  __not_equal_to
 
class  __num_base
 
struct  __numeric_limits_base
 
struct  __numpunct_cache
 
struct  __optional_hash_call_base
 
struct  __optional_hash_call_base< _Tp, _Up, false >
 
struct  __pad
 
struct  __platform_semaphore
 
struct  __plus
 
struct  __poison_hash
 
struct  __poison_hash< _Tp, __void_t< decltype(hash< _Tp >()(declval< _Tp >()))> >
 
struct  __quiet_NaN
 
struct  __quiet_NaN_impl
 
struct  __radix
 
struct  __radix_impl
 
struct  __radix_impl< _Tp, true >
 
struct  __reciprocal_overflow_threshold
 
struct  __reciprocal_overflow_threshold_impl
 
struct  __reciprocal_overflow_threshold_impl< _Tp, true >
 
class  __recursive_mutex_base
 
struct  __remove_pointer_helper
 
struct  __remove_pointer_helper< _Tp, _Up * >
 
struct  __replace_first_arg
 
struct  __replace_first_arg< _Template< _Tp, _Types... >, _Up >
 
struct  __round_error
 
struct  __round_error_impl
 
struct  __round_error_impl< _Tp, true >
 
class  __shared_count
 
class  __shared_ptr
 
class  __shared_ptr_access
 
class  __shared_ptr_access< _Tp, _Lp, false, true >
 
class  __shared_ptr_access< _Tp, _Lp, true, false >
 
struct  __shift_left
 
struct  __shift_right
 
struct  __shrink_to_fit_aux
 
struct  __shrink_to_fit_aux< _Tp, true >
 
struct  __signaling_NaN
 
struct  __signaling_NaN_impl
 
struct  __sp_array_delete
 
struct  __sp_compatible_with
 
struct  __sp_compatible_with< _Up(*)[_Nm], _Up(*)[]>
 
struct  __sp_compatible_with< _Up(*)[_Nm], const _Up(*)[]>
 
struct  __sp_compatible_with< _Up(*)[_Nm], const volatile _Up(*)[]>
 
struct  __sp_compatible_with< _Up(*)[_Nm], volatile _Up(*)[]>
 
struct  __sp_compatible_with< _Yp *, _Tp * >
 
struct  __sp_is_constructible
 
struct  __sp_is_constructible< _Up[], _Yp >
 
struct  __sp_is_constructible< _Up[_Nm], _Yp >
 
struct  __sp_is_constructible_arr
 
struct  __sp_is_constructible_arr< _Up, _Yp, __void_t< _Yp[]> >
 
struct  __sp_is_constructible_arrN
 
struct  __sp_is_constructible_arrN< _Up, _Nm, _Yp, __void_t< _Yp[_Nm]> >
 
struct  __strictest_alignment
 
struct  __strictest_alignment< _Tp, _Types... >
 
class  __syncbuf_base
 
class  __timed_mutex_impl
 
class  __timepunct
 
struct  __timepunct_cache
 
struct  __traitor
 
class  __tree_barrier
 
struct  __true_type
 
struct  __truth_type
 
struct  __truth_type< true >
 
struct  __tuple_cat_result
 
struct  __tuple_compare
 
struct  __tuple_compare< _Tp, _Up, __size, __size >
 
struct  __tuple_concater
 
struct  __tuple_concater< _Ret, _Index_tuple< _Is... >, _Tp, _Tpls... >
 
struct  __tuple_concater< _Ret, _Index_tuple<> >
 
struct  __unary_plus
 
struct  __uninitialized_construct_buf_dispatch
 
struct  __uninitialized_construct_buf_dispatch< true >
 
struct  __use_cache
 
struct  __use_cache< __moneypunct_cache< _CharT, _Intl > >
 
struct  __use_cache< __numpunct_cache< _CharT > >
 
struct  __uses_alloc
 
struct  __uses_alloc0
 
struct  __uses_alloc1
 
struct  __uses_alloc2
 
struct  __uses_alloc< false, _Tp, _Alloc, _Args... >
 
struct  __uses_alloc< true, _Tp, _Alloc, _Args... >
 
struct  __uses_alloc_base
 
struct  __uses_allocator_helper
 
struct  __uses_allocator_helper< _Tp, _Alloc, __void_t< typename _Tp::allocator_type > >
 
struct  __value_exists
 
struct  __value_exists_impl
 
struct  __value_exists_impl< _Trait, _Tp, void_t< decltype(_Trait< _Tp >::value)> >
 
class  __weak_count
 
class  __weak_ptr
 
struct  _Abs
 
struct  _Acos
 
union  _Any_data
 
struct  _Array
 
struct  _Array_copier
 
struct  _Array_copier< _Tp, true >
 
struct  _Array_copy_ctor
 
struct  _Array_copy_ctor< _Tp, true >
 
struct  _Array_default_ctor
 
struct  _Array_default_ctor< _Tp, true >
 
struct  _Array_init_ctor
 
struct  _Array_init_ctor< _Tp, true >
 
struct  _Asin
 
struct  _Atan
 
struct  _Atan2
 
struct  _Base_bitset
 
struct  _Base_bitset< 0 >
 
struct  _Base_bitset< 1 >
 
class  _Bind
 
class  _Bind< _Functor(_Bound_args...)>
 
struct  _Bind_check_arity
 
struct  _Bind_check_arity< _Ret(*)(_Args...), _BoundArgs... >
 
struct  _Bind_check_arity< _Ret(*)(_Args......), _BoundArgs... >
 
struct  _Bind_check_arity< _Tp _Class::*, _BoundArgs... >
 
struct  _Bind_front
 
struct  _Bind_helper
 
struct  _Bind_helper< true, _Func, _BoundArgs... >
 
class  _Bind_result
 
class  _Bind_result< _Result, _Functor(_Bound_args...)>
 
struct  _Bindres_helper
 
struct  _Bit_const_iterator
 
struct  _Bit_iterator
 
struct  _Bit_iterator_base
 
struct  _Bit_reference
 
struct  _Build_index_tuple
 
struct  _Bvector_base
 
class  _Constant
 
struct  _Cos
 
struct  _Cosh
 
class  _Deque_base
 
struct  _Deque_iterator
 
struct  _Destroy_aux
 
struct  _Destroy_aux< true >
 
struct  _Destroy_n_aux
 
struct  _Destroy_n_aux< true >
 
struct  _Enable_copy_move
 
struct  _Enable_copy_move< false, false, false, false, _Tag >
 
struct  _Enable_copy_move< false, false, false, true, _Tag >
 
struct  _Enable_copy_move< false, false, true, false, _Tag >
 
struct  _Enable_copy_move< false, false, true, true, _Tag >
 
struct  _Enable_copy_move< false, true, false, false, _Tag >
 
struct  _Enable_copy_move< false, true, false, true, _Tag >
 
struct  _Enable_copy_move< false, true, true, false, _Tag >
 
struct  _Enable_copy_move< false, true, true, true, _Tag >
 
struct  _Enable_copy_move< true, false, false, false, _Tag >
 
struct  _Enable_copy_move< true, false, false, true, _Tag >
 
struct  _Enable_copy_move< true, false, true, false, _Tag >
 
struct  _Enable_copy_move< true, false, true, true, _Tag >
 
struct  _Enable_copy_move< true, true, false, false, _Tag >
 
struct  _Enable_copy_move< true, true, false, true, _Tag >
 
struct  _Enable_copy_move< true, true, true, false, _Tag >
 
struct  _Enable_default_constructor
 
struct  _Enable_default_constructor< false, _Tag >
 
struct  _Enable_default_constructor_tag
 
struct  _Enable_destructor
 
struct  _Enable_destructor< false, _Tag >
 
struct  _Enable_special_members
 
struct  _Exp
 
class  _Expr
 
struct  _Fnv_hash_impl
 
class  _Function_base
 
class  _Function_handler
 
class  _Function_handler< _Res(_ArgTypes...), _Functor >
 
class  _Function_handler< void, void >
 
struct  _Fwd_list_base
 
struct  _Fwd_list_const_iterator
 
struct  _Fwd_list_iterator
 
struct  _Fwd_list_node
 
struct  _Fwd_list_node_base
 
struct  _Get_money
 
struct  _Get_time
 
struct  _Hash_impl
 
class  _Hash_merge_helper
 
struct  _Hash_merge_helper< ::unordered_map< _Key, _Val, _Hash1, _Eq1, _Alloc >, _Hash2, _Eq2 >
 
struct  _Hash_merge_helper< ::unordered_multimap< _Key, _Val, _Hash1, _Eq1, _Alloc >, _Hash2, _Eq2 >
 
struct  _Hash_merge_helper< ::unordered_multiset< _Val, _Hash1, _Eq1, _Alloc >, _Hash2, _Eq2 >
 
struct  _Hash_merge_helper< ::unordered_set< _Val, _Hash1, _Eq1, _Alloc >, _Hash2, _Eq2 >
 
class  _Hashtable
 
struct  _Head_base
 
struct  _Head_base< _Idx, _Head, false >
 
struct  _Head_base< _Idx, _Head, true >
 
struct  _Identity
 
struct  _Identity< const _Tp >
 
struct  _Index_tuple
 
class  _List_base
 
struct  _List_const_iterator
 
struct  _List_iterator
 
struct  _List_node
 
struct  _Log
 
struct  _Log10
 
struct  _Mem_fn
 
struct  _Mem_fn< _Res _Class::* >
 
class  _Mem_fn_base
 
class  _Mem_fn_base< _MemObjPtr, false >
 
class  _Mu
 
class  _Mu< _Arg, false, false >
 
class  _Mu< _Arg, false, true >
 
class  _Mu< _Arg, true, false >
 
class  _Mu< reference_wrapper< _Tp >, false, false >
 
class  _Mutex_base
 
class  _Mutex_base< _S_mutex >
 
union  _Nocopy_types
 
class  _Node_handle
 
class  _Node_handle< _Value, _Value, _NodeAlloc >
 
class  _Node_handle_common
 
struct  _Node_insert_return
 
struct  _Norm_helper
 
struct  _Norm_helper< true >
 
class  _Not_fn
 
struct  _Optional_base
 
struct  _Optional_base< _Tp, false, true >
 
struct  _Optional_base< _Tp, true, false >
 
struct  _Optional_base< _Tp, true, true >
 
class  _Optional_base_impl
 
struct  _Optional_payload
 
struct  _Optional_payload< _Tp, false, _Copy, _Move >
 
struct  _Optional_payload< _Tp, true, false, false >
 
struct  _Optional_payload< _Tp, true, false, true >
 
struct  _Optional_payload< _Tp, true, true, false >
 
struct  _Optional_payload< _Tp, true, true, true >
 
struct  _Optional_payload_base
 
struct  _Placeholder
 
struct  _Pow
 
struct  _Put_money
 
struct  _Put_time
 
class  _Rb_tree
 
struct  _Rb_tree_const_iterator
 
struct  _Rb_tree_header
 
struct  _Rb_tree_iterator
 
struct  _Rb_tree_key_compare
 
struct  _Rb_tree_merge_helper
 
struct  _Rb_tree_merge_helper< _Rb_tree< _Key, _Val, _Sel, _Cmp1, _Alloc >, _Cmp2 >
 
struct  _Rb_tree_merge_helper<::map< _Key, _Val, _Cmp1, _Alloc >, _Cmp2 >
 
struct  _Rb_tree_merge_helper<::multimap< _Key, _Val, _Cmp1, _Alloc >, _Cmp2 >
 
struct  _Rb_tree_merge_helper<::multiset< _Val, _Cmp1, _Alloc >, _Cmp2 >
 
struct  _Rb_tree_merge_helper<::set< _Val, _Cmp1, _Alloc >, _Cmp2 >
 
struct  _Rb_tree_node
 
struct  _Rb_tree_node_base
 
struct  _Resetiosflags
 
struct  _Sanitize
 
struct  _Sanitize< 0 >
 
struct  _Sanitize_val
 
struct  _Sanitize_val< _Nb, true >
 
struct  _Select1st
 
struct  _Select2nd
 
struct  _Setbase
 
struct  _Setfill
 
struct  _Setiosflags
 
struct  _Setprecision
 
struct  _Setw
 
struct  _Sin
 
struct  _Sinh
 
struct  _Sp_alloc_shared_tag
 
class  _Sp_counted_base
 
class  _Sp_counted_deleter
 
class  _Sp_counted_ptr
 
class  _Sp_counted_ptr_inplace
 
struct  _Sp_ebo_helper
 
struct  _Sp_ebo_helper< _Nm, _Tp, false >
 
struct  _Sp_ebo_helper< _Nm, _Tp, true >
 
struct  _Sp_make_shared_tag
 
struct  _Sp_owner_less
 
struct  _Sp_owner_less< void, void >
 
struct  _Sqrt
 
struct  _Swallow_assign
 
struct  _Tan
 
struct  _Tanh
 
struct  _Target_handler
 
struct  _Target_handler< _Signature, _Functor, false >
 
class  _Temporary_buffer
 
struct  _Tuple_impl
 
struct  _Tuple_impl< _Idx, _Head >
 
struct  _Tuple_impl< _Idx, _Head, _Tail... >
 
struct  _TupleConstraints
 
struct  _TupleConstraints< false, _Types... >
 
class  _ValArray
 
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< const _Tp >
 
class  allocator< const volatile _Tp >
 
class  allocator< void >
 
class  allocator< volatile _Tp >
 
struct  allocator_arg_t
 
struct  allocator_traits
 
struct  allocator_traits< allocator< _Tp > >
 
struct  allocator_traits< allocator< void > >
 
struct  allocator_traits< pmr::polymorphic_allocator< _Tp > >
 
class  any
 
struct  array
 
struct  atomic
 
struct  atomic< _Tp * >
 
struct  atomic< bool >
 
struct  atomic< char >
 
struct  atomic< char16_t >
 
struct  atomic< char32_t >
 
struct  atomic< double >
 
struct  atomic< float >
 
struct  atomic< int >
 
struct  atomic< long >
 
struct  atomic< long double >
 
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
 
class  auto_ptr< void >
 
struct  auto_ptr_ref
 
class  back_insert_iterator
 
class  bad_alloc
 
class  bad_any_cast
 
class  bad_array_new_length
 
class  bad_cast
 
class  bad_exception
 
class  bad_function_call
 
class  bad_optional_access
 
class  bad_typeid
 
class  bad_variant_access
 
class  bad_weak_ptr
 
class  barrier
 
struct  basic_common_reference
 
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_osyncstream
 
class  basic_regex
 
class  basic_streambuf
 
class  basic_string
 
class  basic_string_view
 
class  basic_stringbuf
 
class  basic_stringstream
 
class  basic_syncbuf
 
class  bernoulli_distribution
 
struct  bidirectional_iterator_tag
 
struct  binary_function
 
class  binary_negate
 
class  binder1st
 
class  binder2nd
 
class  binomial_distribution
 
struct  bit_and
 
struct  bit_and< void >
 
struct  bit_not
 
struct  bit_not< void >
 
struct  bit_or
 
struct  bit_or< void >
 
struct  bit_xor
 
struct  bit_xor< void >
 
class  bitset
 
class  boyer_moore_horspool_searcher
 
class  boyer_moore_searcher
 
struct  Catalog_info
 
class  Catalogs
 
class  cauchy_distribution
 
struct  char_traits
 
struct  char_traits< __gnu_cxx::character< _Value, _Int, _St > >
 
struct  char_traits< char >
 
struct  char_traits< char16_t >
 
struct  char_traits< char32_t >
 
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  codecvt_byname< char16_t, char, mbstate_t >
 
class  codecvt_byname< char32_t, char, mbstate_t >
 
class  codecvt_utf16
 
class  codecvt_utf16< char16_t, _Maxcode, _Mode >
 
class  codecvt_utf16< char32_t, _Maxcode, _Mode >
 
class  codecvt_utf16< wchar_t, _Maxcode, _Mode >
 
class  codecvt_utf8
 
class  codecvt_utf8< char16_t, _Maxcode, _Mode >
 
class  codecvt_utf8< char32_t, _Maxcode, _Mode >
 
class  codecvt_utf8< wchar_t, _Maxcode, _Mode >
 
class  codecvt_utf8_utf16
 
class  codecvt_utf8_utf16< char16_t, _Maxcode, _Mode >
 
class  codecvt_utf8_utf16< char32_t, _Maxcode, _Mode >
 
class  codecvt_utf8_utf16< wchar_t, _Maxcode, _Mode >
 
class  collate
 
class  collate_byname
 
struct  common_comparison_category
 
struct  common_comparison_category< _Tp >
 
struct  common_comparison_category< partial_ordering >
 
struct  common_comparison_category< strong_ordering >
 
struct  common_comparison_category< weak_ordering >
 
struct  common_comparison_category<>
 
struct  common_reference
 
struct  common_reference< _Tp0 >
 
struct  common_reference<>
 
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
 
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
 
struct  conditional< false, _Iftrue, _Iffalse >
 
struct  conjunction
 
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  counting_semaphore
 
class  ctype
 
class  ctype< char >
 
class  ctype< wchar_t >
 
struct  ctype_base
 
class  ctype_byname
 
class  ctype_byname< char >
 
class  ctype_byname< wchar_t >
 
class  decay
 
struct  default_delete
 
struct  default_delete< _Tp[]>
 
class  default_searcher
 
struct  default_sentinel_t
 
struct  defer_lock_t
 
class  deque
 
struct  destroying_delete_t
 
class  discard_block_engine
 
class  discrete_distribution
 
struct  disjunction
 
struct  divides
 
struct  divides< void >
 
class  domain_error
 
struct  enable_if
 
struct  enable_if< true, _Tp >
 
class  enable_shared_from_this
 
struct  equal_to
 
struct  equal_to< experimental::propagate_const< _Tp > >
 
struct  equal_to< void >
 
class  error_category
 
class  error_code
 
class  error_condition
 
class  exception
 
class  exponential_distribution
 
struct  extent
 
struct  extent< _Tp[], _Uint >
 
struct  extent< _Tp[_Size], _Uint >
 
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
 
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< _Tp * >
 
struct  greater< experimental::propagate_const< _Tp > >
 
struct  greater< void >
 
struct  greater_equal
 
struct  greater_equal< _Tp * >
 
struct  greater_equal< experimental::propagate_const< _Tp > >
 
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< 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::observer_ptr< _Tp > >
 
struct  hash< experimental::optional< _Tp > >
 
struct  hash< experimental::propagate_const< _Tp > >
 
struct  hash< experimental::shared_ptr< _Tp > >
 
struct  hash< experimental::string_view >
 
struct  hash< experimental::u16string_view >
 
struct  hash< experimental::u32string_view >
 
struct  hash< experimental::wstring_view >
 
struct  hash< float >
 
struct  hash< int >
 
struct  hash< long >
 
struct  hash< long double >
 
struct  hash< long long >
 
struct  hash< monostate >
 
struct  hash< nullptr_t >
 
struct  hash< optional< _Tp > >
 
struct  hash< pmr::string >
 
struct  hash< pmr::u16string >
 
struct  hash< pmr::u32string >
 
struct  hash< pmr::wstring >
 
struct  hash< shared_ptr< _Tp > >
 
struct  hash< short >
 
struct  hash< signed char >
 
struct  hash< string >
 
struct  hash< string_view >
 
struct  hash< thread::id >
 
struct  hash< type_index >
 
struct  hash< u16string >
 
struct  hash< u16string_view >
 
struct  hash< u32string >
 
struct  hash< u32string_view >
 
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< variant< _Types... > >
 
struct  hash< wchar_t >
 
struct  hash< wstring >
 
struct  hash< wstring_view >
 
struct  hash<::bitset< 0 > >
 
struct  hash<::bitset< _Nb > >
 
struct  hash<::vector< bool, _Alloc > >
 
struct  identity
 
struct  in_place_index_t
 
struct  in_place_t
 
struct  in_place_type_t
 
struct  incrementable_traits
 
struct  incrementable_traits< _Tp * >
 
struct  incrementable_traits< _Tp >
 
struct  incrementable_traits< common_iterator< _It, _Sent > >
 
struct  incrementable_traits< const _Iter >
 
struct  incrementable_traits< projected< _Iter, _Proj > >
 
class  independent_bits_engine
 
class  indirect_array
 
struct  indirectly_readable_traits
 
struct  indirectly_readable_traits< __gnu_cxx::_Pointer_adapter< _Policy > >
 
struct  indirectly_readable_traits< _Iter >
 
struct  indirectly_readable_traits< _Tp * >
 
struct  indirectly_readable_traits< _Tp >
 
struct  indirectly_readable_traits< const _Iter >
 
class  initializer_list
 
struct  input_iterator_tag
 
class  insert_iterator
 
class  insert_iterator< __gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqKey, _Alloc > >
 
class  insert_iterator< __gnu_cxx::hash_multimap< _Key, _Tp, _HashFn, _EqKey, _Alloc > >
 
class  insert_iterator< __gnu_cxx::hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc > >
 
class  insert_iterator< __gnu_cxx::hash_set< _Value, _HashFcn, _EqualKey, _Alloc > >
 
class  insert_iterator< __gnu_cxx::slist< _Tp, _Alloc > >
 
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_array< _Tp[]>
 
struct  is_array< _Tp[_Size]>
 
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_const< _Tp const >
 
struct  is_constructible
 
struct  is_convertible
 
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_code_enum< io_errc >
 
struct  is_error_condition_enum
 
struct  is_error_condition_enum< errc >
 
struct  is_final
 
struct  is_floating_point
 
struct  is_function
 
struct  is_function< _Tp & >
 
struct  is_function< _Tp && >
 
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_lvalue_reference< _Tp & >
 
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_placeholder< const _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_rvalue_reference< _Tp && >
 
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
 
struct  is_volatile< _Tp volatile >
 
class  istream_iterator
 
class  istreambuf_iterator
 
class  istrstream
 
struct  iterator
 
struct  iterator_traits
 
struct  iterator_traits< _Tp * >
 
struct  iterator_traits< common_iterator< _It, _Sent > >
 
struct  iterator_traits< counted_iterator< _It > >
 
class  jthread
 
class  latch
 
class  length_error
 
struct  less
 
struct  less< _Tp * >
 
struct  less< experimental::propagate_const< _Tp > >
 
struct  less< void >
 
struct  less_equal
 
struct  less_equal< _Tp * >
 
struct  less_equal< experimental::propagate_const< _Tp > >
 
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
 
struct  monostate
 
class  move_iterator
 
class  move_sentinel
 
class  multimap
 
struct  multiplies
 
struct  multiplies< void >
 
class  multiset
 
class  mutex
 
struct  negate
 
struct  negate< void >
 
struct  negation
 
class  negative_binomial_distribution
 
class  nested_exception
 
class  normal_distribution
 
struct  nostopstate_t
 
struct  not_equal_to
 
struct  not_equal_to< experimental::propagate_const< _Tp > >
 
struct  not_equal_to< void >
 
struct  nothrow_t
 
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< const _Tp >
 
struct  numeric_limits< const volatile _Tp >
 
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< volatile _Tp >
 
struct  numeric_limits< wchar_t >
 
class  numpunct
 
class  numpunct_byname
 
struct  once_flag
 
class  optional
 
class  ostream_iterator
 
class  ostreambuf_iterator
 
class  ostrstream
 
class  out_of_range
 
struct  output_iterator_tag
 
class  overflow_error
 
struct  owner_less
 
struct  owner_less< __shared_ptr< _Tp, _Lp > >
 
struct  owner_less< __weak_ptr< _Tp, _Lp > >
 
struct  owner_less< shared_ptr< _Tp > >
 
struct  owner_less< void >
 
struct  owner_less< weak_ptr< _Tp > >
 
class  packaged_task
 
class  packaged_task< _Res(_ArgTypes...)>
 
struct  pair
 
class  partial_ordering
 
class  piecewise_constant_distribution
 
struct  piecewise_construct_t
 
class  piecewise_linear_distribution
 
struct  plus
 
struct  plus< void >
 
class  pointer_to_binary_function
 
class  pointer_to_unary_function
 
struct  pointer_traits
 
struct  pointer_traits< __gnu_cxx::_Pointer_adapter< _Storage_policy > >
 
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  rank< _Tp[]>
 
struct  rank< _Tp[_Size]>
 
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_all_extents< _Tp[]>
 
struct  remove_all_extents< _Tp[_Size]>
 
struct  remove_const
 
struct  remove_const< _Tp const >
 
struct  remove_cv
 
struct  remove_cv< const _Tp >
 
struct  remove_cv< const volatile _Tp >
 
struct  remove_cv< volatile _Tp >
 
struct  remove_cvref
 
struct  remove_cvref< _Tp & >
 
struct  remove_cvref< _Tp && >
 
struct  remove_extent
 
struct  remove_extent< _Tp[]>
 
struct  remove_extent< _Tp[_Size]>
 
struct  remove_pointer
 
struct  remove_reference
 
struct  remove_reference< _Tp & >
 
struct  remove_reference< _Tp && >
 
struct  remove_volatile
 
struct  remove_volatile< _Tp volatile >
 
struct  result_of
 
struct  result_of< _Functor(_ArgTypes...)>
 
class  reverse_iterator
 
class  runtime_error
 
class  scoped_allocator_adaptor
 
class  scoped_lock
 
class  scoped_lock< _Mutex >
 
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  span
 
class  stack
 
class  stop_callback
 
class  stop_source
 
class  stop_token
 
class  strong_ordering
 
class  strstream
 
class  strstreambuf
 
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 >
 
class  tuple<>
 
struct  tuple_element
 
struct  tuple_element< 0, const ranges::subrange< _Iter, _Sent, _Kind > >
 
struct  tuple_element< 0, pair< _Tp1, _Tp2 > >
 
struct  tuple_element< 0, ranges::subrange< _Iter, _Sent, _Kind > >
 
struct  tuple_element< 0, tuple< _Head, _Tail... > >
 
struct  tuple_element< 1, const ranges::subrange< _Iter, _Sent, _Kind > >
 
struct  tuple_element< 1, pair< _Tp1, _Tp2 > >
 
struct  tuple_element< 1, ranges::subrange< _Iter, _Sent, _Kind > >
 
struct  tuple_element< __i, const _Tp >
 
struct  tuple_element< __i, const volatile _Tp >
 
struct  tuple_element< __i, tuple< _Head, _Tail... > >
 
struct  tuple_element< __i, tuple<> >
 
struct  tuple_element< __i, volatile _Tp >
 
struct  tuple_element< _Ind, array< _Tp, _Nm > >
 
struct  tuple_size
 
struct  tuple_size< array< _Tp, _Nm > >
 
struct  tuple_size< const __enable_if_has_tuple_size< _Tp > >
 
struct  tuple_size< const volatile __enable_if_has_tuple_size< _Tp > >
 
struct  tuple_size< pair< _Tp1, _Tp2 > >
 
struct  tuple_size< ranges::subrange< _Iter, _Sent, _Kind > >
 
struct  tuple_size< tuple< _Elements... > >
 
struct  tuple_size< volatile __enable_if_has_tuple_size< _Tp > >
 
struct  type_identity
 
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  unreachable_sentinel_t
 
struct  unwrap_ref_decay
 
struct  unwrap_reference
 
struct  unwrap_reference< reference_wrapper< _Tp > >
 
struct  uses_allocator
 
struct  uses_allocator< priority_queue< _Tp, _Sequence, _Compare >, _Alloc >
 
struct  uses_allocator< promise< _Res >, _Alloc >
 
struct  uses_allocator< queue< _Tp, _Seq >, _Alloc >
 
struct  uses_allocator< stack< _Tp, _Seq >, _Alloc >
 
struct  uses_allocator< tuple< _Types... >, _Alloc >
 
class  valarray
 
class  variant
 
struct  variant_alternative
 
struct  variant_alternative< 0, variant< _First, _Rest... > >
 
struct  variant_alternative< _Np, const _Variant >
 
struct  variant_alternative< _Np, const volatile _Variant >
 
struct  variant_alternative< _Np, variant< _First, _Rest... > >
 
struct  variant_alternative< _Np, volatile _Variant >
 
struct  variant_size
 
struct  variant_size< const _Variant >
 
struct  variant_size< const volatile _Variant >
 
struct  variant_size< variant< _Types... > >
 
struct  variant_size< volatile _Variant >
 
class  vector
 
class  vector< bool, _Alloc >
 
class  wbuffer_convert
 
class  weak_ordering
 
class  weak_ptr
 
class  weibull_distribution
 
class  wstring_convert
 

Typedefs

template<typename _Alloc , typename _Up >
using __alloc_rebind = typename __allocator_traits_base::template __rebind< _Alloc, _Up >::type
 
template<typename _Tp >
using __allocator_base = __gnu_cxx::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 > && > >
 
template<typename _Fn , typename... _Args>
using __async_result_of = typename __invoke_result< typename decay< _Fn >::type, typename decay< _Args >::type... >::type
 
template<typename _Tp >
using __atomic_diff_t = typename atomic< _Tp >::difference_type
 
typedef unsigned char __atomic_flag_data_type
 
template<typename _Tp >
using __atomic_val_t = typename atomic< _Tp >::value_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<typename _Tp , typename _Hash >
using __cache_default = __not_< __and_< __is_fast_hash< _Hash >, __is_nothrow_invocable< const _Hash &, const _Tp & > >>
 
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 > >
 
template<typename _Tp >
using __empty_not_final = typename conditional< __is_final(_Tp), false_type, __is_empty_non_tuple< _Tp > >::type
 
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<typename _Tp >
using __get_first_arg_t = typename __get_first_arg< _Tp >::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 _Alloc , typename _Tp >
using __is_erased_or_convertible = __or_< is_convertible< _Alloc, _Tp >, is_same< _Tp, __erased_type > >
 
template<typename _Tp , typename _Up >
using __is_nothrow_assignable_impl = __bool_constant< __is_nothrow_assignable(_Tp, _Up)>
 
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< add_const_t< __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 >
using __make_not_void = typename conditional< is_void< _Tp >::value, __undefined, _Tp >::type
 
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 _Tp , typename _Up >
using __replace_first_arg_t = typename __replace_first_arg< _Tp, _Up >::type
 
using __rvalue_stream_extraction_t = _Is &&
 
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 _Tp , typename _Alloc , typename... _Args>
using __uses_alloc_t = __uses_alloc< uses_allocator< _Tp, _Alloc >::value, _Tp, _Alloc, _Args... >
 
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 _Equal , typename _Hash , typename _Allocator >
using _Hashtable_enable_default_ctor = _Enable_default_constructor< __and_< is_default_constructible< _Equal >, is_default_constructible< _Hash >, is_default_constructible< _Allocator > >{}, __detail::_Hash_node_base >
 
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 _Alloc >
using _RequireAllocator = typename enable_if< __is_allocator< _Alloc >::value, _Alloc >::type
 
template<typename _InIter >
using _RequireInputIter = __enable_if_t< is_convertible< __iterator_category_t< _InIter >, input_iterator_tag >::value >
 
template<typename _Alloc >
using _RequireNotAllocator = typename enable_if<!__is_allocator< _Alloc >::value, _Alloc >::type
 
template<typename _Hash >
using _RequireNotAllocatorOrIntegral = __enable_if_t<!__or_< is_integral< _Hash >, __is_allocator< _Hash > >::value >
 
template<std::size_t __i, typename _Tuple >
using _Safe_tuple_element_t = typename enable_if<(__i< tuple_size< _Tuple >::value), tuple_element< __i, _Tuple > >::type::type
 
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_tatomic_ptrdiff_t
 
typedef atomic< signed char > atomic_schar
 
typedef atomic< short > atomic_short
 
typedef atomic< size_tatomic_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)>
 
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 basic_ofstream< char > ofstream
 
typedef basic_ostream< char > ostream
 
typedef basic_ostringstream< char > ostringstream
 
using osyncstream = basic_osyncstream< char >
 
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_iteratorsmatch
 
typedef regex_iterator< string::const_iteratorsregex_iterator
 
typedef regex_token_iterator< string::const_iteratorsregex_token_iterator
 
typedef sub_match< string::const_iteratorssub_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
 
using syncbuf = basic_syncbuf< char >
 
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
 
using wosyncstream = basic_osyncstream< wchar_t >
 
typedef basic_regex< wchar_t > wregex
 
typedef match_results< wstring::const_iteratorwsmatch
 
typedef regex_iterator< wstring::const_iteratorwsregex_iterator
 
typedef regex_token_iterator< wstring::const_iteratorwsregex_token_iterator
 
typedef sub_match< wstring::const_iteratorwssub_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
 
using wsyncbuf = basic_syncbuf< wchar_t >
 
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_threshold }
 
enum  { _S_chunk_size }
 
enum  { _S_word_bit }
 
enum class  __barrier_phase_t : unsigned char
 
enum  __memory_order_modifier { __memory_order_mask , __memory_order_modifier_mask , __memory_order_hle_acquire , __memory_order_hle_release }
 
enum  _Ios_Fmtflags {
  _S_boolalpha , _S_dec , _S_fixed , _S_hex , _S_internal , _S_left , _S_oct , _S_right , _S_scientific , _S_showbase , _S_showpoint , _S_showpos , _S_skipws , _S_unitbuf , _S_uppercase , _S_adjustfield , _S_basefield , _S_floatfield , _S_ios_fmtflags_end , _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_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 _RandomAccessIterator , typename _Distance >
constexpr void __advance (_RandomAccessIterator &__i, _Distance __n, random_access_iterator_tag)
 
template<typename _Alloc >
constexpr void __alloc_on_copy (_Alloc &__one, const _Alloc &__two)
 
template<typename _Alloc >
constexpr _Alloc __alloc_on_copy (const _Alloc &__a)
 
template<typename _Alloc >
constexpr void __alloc_on_move (_Alloc &__one, _Alloc &__two)
 
template<typename _Alloc >
constexpr void __alloc_on_swap (_Alloc &__one, _Alloc &__two)
 
template<typename _Alloc >
__allocated_ptr< _Alloc > __allocate_guarded (_Alloc &__a)
 
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)
 
constexpr memory_order __cmpexch_failure_order (memory_order __m) noexcept
 
constexpr memory_order __cmpexch_failure_order2 (memory_order __m) noexcept
 
template<typename _Tp >
_Tp __complex_abs (const complex< _Tp > &__z)
 
__complex__ double __complex_acos (__complex__ double __z)
 
__complex__ float __complex_acos (__complex__ float __z)
 
__complex__ long double __complex_acos (const __complex__ long double &__z)
 
template<typename _Tp >
std::complex< _Tp > __complex_acos (const std::complex< _Tp > &__z)
 
__complex__ double __complex_acosh (__complex__ double __z)
 
__complex__ float __complex_acosh (__complex__ float __z)
 
__complex__ long double __complex_acosh (const __complex__ long double &__z)
 
template<typename _Tp >
std::complex< _Tp > __complex_acosh (const std::complex< _Tp > &__z)
 
template<typename _Tp >
_Tp __complex_arg (const complex< _Tp > &__z)
 
__complex__ double __complex_asin (__complex__ double __z)
 
__complex__ float __complex_asin (__complex__ float __z)
 
__complex__ long double __complex_asin (const __complex__ long double &__z)
 
template<typename _Tp >
std::complex< _Tp > __complex_asin (const std::complex< _Tp > &__z)
 
__complex__ double __complex_asinh (__complex__ double __z)
 
__complex__ float __complex_asinh (__complex__ float __z)
 
__complex__ long double __complex_asinh (const __complex__ long double &__z)
 
template<typename _Tp >
std::complex< _Tp > __complex_asinh (const std::complex< _Tp > &__z)
 
__complex__ double __complex_atan (__complex__ double __z)
 
__complex__ float __complex_atan (__complex__ float __z)
 
__complex__ long double __complex_atan (const __complex__ long double &__z)
 
template<typename _Tp >
std::complex< _Tp > __complex_atan (const std::complex< _Tp > &__z)
 
__complex__ double __complex_atanh (__complex__ double __z)
 
__complex__ float __complex_atanh (__complex__ float __z)
 
__complex__ long double __complex_atanh (const __complex__ long double &__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)
 
complex< double > __complex_proj (const complex< double > &__z)
 
complex< float > __complex_proj (const complex< float > &__z)
 
complex< long double > __complex_proj (const complex< long double > &__z)
 
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)
 
template<typename _Signature , typename _Fn , typename _Alloc = std::allocator<int>>
static shared_ptr< __future_base::_Task_state_base< _Signature > > __create_task_state (_Fn &&__fn, const _Alloc &__a=_Alloc())
 
constexpr size_t __deque_buf_size (size_t __size)
 
template<typename _Tp >
ptrdiff_t __distance (::_List_const_iterator< _Tp >, ::_List_const_iterator< _Tp >, input_iterator_tag)
 
template<typename _Tp >
ptrdiff_t __distance (::_List_iterator< _Tp >, ::_List_iterator< _Tp >, input_iterator_tag)
 
template<typename _InputIterator >
constexpr iterator_traits< _InputIterator >::difference_type __distance (_InputIterator __first, _InputIterator __last, input_iterator_tag)
 
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)
 
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)
 
void __fill_bvector (::_Bit_type *__v, unsigned int __first, unsigned int __last, bool __x)
 
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 _RandomAccessIterator , typename _Compare >
constexpr void __final_insertion_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 
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 _RandomAccessIterator , typename _Compare >
constexpr void __heap_select (_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp)
 
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 _RandomAccessIterator , typename _Compare >
constexpr void __insertion_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 
template<typename _CharT , typename _ValueT >
int __int_to_char (_CharT *__bufend, _ValueT __v, const _CharT *__lit, ios_base::fmtflags __flags, bool __dec)
 
template<typename _RandomAccessIterator , typename _Size , typename _Compare >
constexpr void __introselect (_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Size __depth_limit, _Compare __comp)
 
template<typename _RandomAccessIterator , typename _Size , typename _Compare >
constexpr void __introsort_loop (_RandomAccessIterator __first, _RandomAccessIterator __last, _Size __depth_limit, _Compare __comp)
 
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... >)
 
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 = typename conditional<__move_if_noexcept_cond <typename iterator_traits<_Iterator>::value_type>::value, _Iterator, move_iterator<_Iterator>>::type>
constexpr _ReturnType __make_move_if_noexcept_iterator (_Iterator __i)
 
template<typename _Tp , typename _ReturnType = typename conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp*, move_iterator<_Tp*>>::type>
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, _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 >
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 >
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 _CharT , typename _Traits >
void __ostream_fill (basic_ostream< _CharT, _Traits > &__out, streamsize __n)
 
template<typename _CharT , typename _Traits >
basic_ostream< _CharT, _Traits > & __ostream_insert (basic_ostream< _CharT, _Traits > &__out, const _CharT *__s, streamsize __n)
 
template ostream__ostream_insert (ostream &, const char *, streamsize)
 
template wostream__ostream_insert (wostream &, const wchar_t *, streamsize)
 
template<typename _CharT , typename _Traits >
void __ostream_write (basic_ostream< _CharT, _Traits > &__out, const _CharT *__s, streamsize __n)
 
template<typename _RandomAccessIterator , typename _Compare >
constexpr void __partial_sort (_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp)
 
template<typename _InputIterator , typename _RandomAccessIterator , typename _Compare >
constexpr _RandomAccessIterator __partial_sort_copy (_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
 
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 (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 
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 _Distance , typename _Compare >
void __stable_sort_adaptive (_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 __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_regex_error (regex_constants::error_type __ecode)
 
void __throw_regex_error (regex_constants::error_type __ecode, const char *__what)
 
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 _RandomAccessIterator , typename _Compare >
constexpr void __unguarded_insertion_sort (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 
template<typename _RandomAccessIterator , typename _Compare >
constexpr void __unguarded_linear_insert (_RandomAccessIterator __last, _Compare __comp)
 
template<typename _RandomAccessIterator , typename _Compare >
constexpr _RandomAccessIterator __unguarded_partition (_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __pivot, _Compare __comp)
 
template<typename _RandomAccessIterator , typename _Compare >
constexpr _RandomAccessIterator __unguarded_partition_pivot (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 
template<typename _Pointer , typename _ForwardIterator >
void __uninitialized_construct_buf (_Pointer __first, _Pointer __last, _ForwardIterator __seed)
 
template<typename _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 , typename _Alloc , typename... _Args>
void __use_alloc (const _Alloc &&)=delete
 
template<typename _Tp , typename _Alloc , typename... _Args>
constexpr __uses_alloc_t< _Tp, _Alloc, _Args... > __use_alloc (const _Alloc &__a)
 
template<typename _Tp , typename _Alloc , typename... _Args>
void __uses_allocator_construct (const _Alloc &__a, _Tp *__ptr, _Args &&... __args)
 
template<typename _Tp , typename... _Args>
void __uses_allocator_construct_impl (__uses_alloc0 __a, _Tp *__ptr, _Args &&... __args)
 
template<typename _Tp , typename _Alloc , typename... _Args>
void __uses_allocator_construct_impl (__uses_alloc1< _Alloc > __a, _Tp *__ptr, _Args &&... __args)
 
template<typename _Tp , typename _Alloc , typename... _Args>
void __uses_allocator_construct_impl (__uses_alloc2< _Alloc > __a, _Tp *__ptr, _Args &&... __args)
 
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 >
decltype(auto) __variant_cast (_Tp &&__rhs)
 
template<size_t _Np, typename _Variant , typename... _Args>
void __variant_construct_by_index (_Variant &__v, _Args &&... __args)
 
bool __verify_grouping (const char *__grouping, size_t __grouping_size, const string &__grouping_tmp) throw ()
 
template<std::size_t _Ind, typename... _Tp>
auto __volget (const volatile tuple< _Tp... > &__tuple) -> __tuple_element_t< _Ind, tuple< _Tp... >> const volatile &
 
template<std::size_t _Ind, typename... _Tp>
auto __volget (volatile tuple< _Tp... > &__tuple) -> __tuple_element_t< _Ind, tuple< _Tp... >> volatile &
 
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>
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 _ForwardIterator , typename _Allocator >
void _Destroy (_ForwardIterator __first, _ForwardIterator __last, _Allocator &__alloc)
 
template<typename _ForwardIterator , typename _Tp >
void _Destroy (_ForwardIterator __first, _ForwardIterator __last, allocator< _Tp > &)
 
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 > &)
 
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 >
constexpr __gnu_cxx::__enable_if< __is_integer< _Tp >::__value, double >::__type acosh (_Tp __x)
 
template<typename _Tp >
std::complex< _Tp > acosh (const std::complex< _Tp > &)
 
constexpr float acosh (float __x)
 
constexpr long double acosh (long double __x)
 
template<typename _Tp >
constexpr _Tp * addressof (_Tp &__r) noexcept
 
template<typename _Tp >
const _Tp * addressof (const _Tp &&)=delete
 
template<class _ExecutionPolicy , class _ForwardIterator1 , class _ForwardIterator2 >
__pstl::__internal::__enable_if_execution_policy< _ExecutionPolicy, _ForwardIterator2 > adjacent_difference (_ExecutionPolicy &&__exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first)
 
template<class _ExecutionPolicy , class _ForwardIterator1 , class _ForwardIterator2 , class _BinaryOperation >
__pstl::__internal::__enable_if_execution_policy< _ExecutionPolicy, _ForwardIterator2 > adjacent_difference (_ExecutionPolicy &&__exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first, _BinaryOperation op)
 
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<class _ExecutionPolicy , class _ForwardIterator >
__pstl::__internal::__enable_if_execution_policy< _ExecutionPolicy, _ForwardIterator > adjacent_find (_ExecutionPolicy &&__exec, _ForwardIterator __first, _ForwardIterator __last)
 
template<class _ExecutionPolicy , class _ForwardIterator , class _BinaryPredicate >
__pstl::__internal::__enable_if_execution_policy< _ExecutionPolicy, _ForwardIterator > adjacent_find (_ExecutionPolicy &&__exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
 
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<class _ExecutionPolicy , class _ForwardIterator , class _Pred >
__pstl::__internal::__enable_if_execution_policy< _ExecutionPolicy, bool > all_of (_ExecutionPolicy &&__exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred)
 
template<class _ExecutionPolicy , class _ForwardIterator , class _Predicate >
__pstl::__internal::__enable_if_execution_policy< _ExecutionPolicy, bool > all_of (_ExecutionPolicy &&__exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
 
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<class _ExecutionPolicy , class _ForwardIterator , class _Predicate >
__pstl::__internal::__enable_if_execution_policy< _ExecutionPolicy, bool > any_of (_ExecutionPolicy &&__exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
 
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 _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 > &)
 
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 >
constexpr __gnu_cxx::__enable_if< __is_integer< _Tp >::__value, double >::__type asinh (_Tp __x)
 
template<typename _Tp >
std::complex< _Tp > asinh (const std::complex< _Tp > &)
 
constexpr float asinh (float __x)
 
constexpr long double asinh (long double __x)
 
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 > &)
 
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 >
constexpr __gnu_cxx::__enable_if< __is_integer< _Tp >::__value, double >::__type atanh (_Tp __x)
 
template<typename _Tp >
std::complex< _Tp > atanh (const std::complex< _Tp > &)
 
constexpr float atanh (float __x)
 
constexpr long double atanh (long double __x)
 
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