A | B | C | D | E | F | G | H | I | J | L | M | N | O | P | Q | R | S | T | U | V | W | _

A: add_const (std); add_cv (std); add_lvalue_reference (std); add_pointer (std); add_rvalue_reference (std); add_volatile (std); adopt_lock_t (std); aligned_storage (std); aligned_union (std); alignment_of (std); allocator (std); allocator< void > (std); allocator_traits (std); allocator_traits< allocator< _Tp > > (std); allocator_traits< allocator< void > > (std); allocator_traits< pmr::polymorphic_allocator< _Tp > > (std); limit_condition::always_adjustor (__gnu_cxx); random_condition::always_adjustor (__gnu_cxx); annotate_base (__gnu_cxx); any (std); any (std::experimental); any (std::experimental::fundamentals_v1); array (std); associative_tag (__gnu_pbds); atomic (std); atomic< _Tp * > (std); atomic< bool > (std); atomic< char > (std); atomic< char16_t > (std); atomic< char32_t > (std); atomic< int > (std); atomic< long > (std); atomic< long long > (std); atomic< short > (std); atomic< signed char > (std); atomic< unsigned char > (std); atomic< unsigned int > (std); atomic< unsigned long > (std); atomic< unsigned long long > (std); atomic< unsigned short > (std); atomic< wchar_t > (std); atomic_flag (std); atomic_ref (std); auto_ptr (std); auto_ptr_ref (std)

B: back_insert_iterator (std); bad_alloc (std); bad_any_cast (std::experimental); bad_any_cast (std); bad_any_cast (std::experimental::fundamentals_v1); bad_cast (std); bad_exception (std); bad_function_call (std); bad_optional_access (std); bad_optional_access (std::experimental); bad_optional_access (std::experimental::fundamentals_v1); bad_typeid (std); bad_weak_ptr (std); balanced_quicksort_tag (__gnu_parallel); balanced_tag (__gnu_parallel); bases (std::tr2); basic_branch (__gnu_pbds); basic_branch_tag (__gnu_pbds); basic_filebuf (std); basic_fstream (std); basic_hash_table (__gnu_pbds); basic_hash_tag (__gnu_pbds); basic_ifstream (std); basic_invalidation_guarantee (__gnu_pbds); basic_ios (std); basic_iostream (std); basic_istream (std); basic_istringstream (std); basic_ofstream (std); basic_ostream (std); basic_ostringstream (std); basic_regex (std); basic_streambuf (std); basic_string (__gnu_debug); basic_string (std); basic_string_view (std); basic_string_view (std::experimental::fundamentals_v1); basic_string_view (std::experimental); basic_stringbuf (std); basic_stringstream (std); bernoulli_distribution (std); bidirectional_iterator_tag (std); bin_search_tree_const_it_ (__gnu_pbds::detail); bin_search_tree_const_node_it_ (__gnu_pbds::detail); bin_search_tree_it_ (__gnu_pbds::detail); bin_search_tree_node_it_ (__gnu_pbds::detail); bin_search_tree_traits (__gnu_pbds::detail); bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, Node, _Alloc > (__gnu_pbds::detail); binary_compose (__gnu_cxx); binary_function (std); binary_heap (__gnu_pbds::detail); binary_heap_const_iterator_ (__gnu_pbds::detail); binary_heap_point_const_iterator_ (__gnu_pbds::detail); binary_heap_tag (__gnu_pbds); binary_negate (std); binder1st (std); binder2nd (std); binomial_distribution (std); binomial_heap (__gnu_pbds::detail); binomial_heap_base (__gnu_pbds::detail); binomial_heap_tag (__gnu_pbds); bitmap_allocator (__gnu_cxx); bitset (std::__debug); bitset (std); bool_set (std::tr2); branch_policy (__gnu_pbds::detail); branch_policy< Node_CItr, Node_CItr, _Alloc > (__gnu_pbds::detail)

C: cauchy_distribution (std); cc_hash_max_collision_check_resize_trigger (__gnu_pbds); cc_hash_table (__gnu_pbds); cc_hash_tag (__gnu_pbds); cc_ht_map (__gnu_pbds::detail); char_traits (__gnu_cxx); char_traits (std); char_traits< __gnu_cxx::character< _Value, _Int, _St > > (std); char_traits< char > (std); char_traits< wchar_t > (std); character (__gnu_cxx); chi_squared_distribution (std); codecvt (std); codecvt< _InternT, _ExternT, encoding_state > (std); codecvt< char, char, mbstate_t > (std); codecvt< char16_t, char, mbstate_t > (std); codecvt< char32_t, char, mbstate_t > (std); codecvt< wchar_t, char, mbstate_t > (std); codecvt_base (std); codecvt_byname (std); collate (std); collate_byname (std); common_iterator (std); common_type (std); common_type< chrono::duration< _Rep, _Period > > (std); common_type< chrono::duration< _Rep, _Period >, chrono::duration< _Rep, _Period > > (std); common_type< chrono::duration< _Rep1, _Period1 >, chrono::duration< _Rep2, _Period2 > > (std); common_type< chrono::time_point< _Clock, _Duration > > (std); common_type< chrono::time_point< _Clock, _Duration >, chrono::time_point< _Clock, _Duration > > (std); common_type< chrono::time_point< _Clock, _Duration1 >, chrono::time_point< _Clock, _Duration2 > > (std); compare_three_way_result (std); complex (std); complex< double > (std); complex< float > (std); complex< long double > (std); cond_dealtor (__gnu_pbds::detail); ov_tree_map::cond_dtor (__gnu_pbds::detail); condition_base (__gnu_cxx); condition_variable (std); condition_variable_any (std); conditional (std); pat_trie_base::_Inode::const_iterator (__gnu_pbds::detail); const_mem_fun1_ref_t (std); const_mem_fun1_t (std); const_mem_fun_ref_t (std); const_mem_fun_t (std); constant_binary_fun (__gnu_cxx); constant_size_blocks_tag (__gnu_parallel); constant_unary_fun (__gnu_cxx); constant_void_fun (__gnu_cxx); container_base_dispatch (__gnu_pbds::detail); container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binary_heap_tag, null_type > (__gnu_pbds::detail); container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binomial_heap_tag, null_type > (__gnu_pbds::detail); container_base_dispatch< _VTp, Cmp_Fn, _Alloc, pairing_heap_tag, null_type > (__gnu_pbds::detail); container_base_dispatch< _VTp, Cmp_Fn, _Alloc, rc_binomial_heap_tag, null_type > (__gnu_pbds::detail); container_base_dispatch< _VTp, Cmp_Fn, _Alloc, thin_heap_tag, null_type > (__gnu_pbds::detail); container_base_dispatch< Key, Mapped, _Alloc, cc_hash_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, Mapped, _Alloc, gp_hash_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, Mapped, _Alloc, list_update_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, Mapped, _Alloc, ov_tree_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, Mapped, _Alloc, pat_trie_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, Mapped, _Alloc, rb_tree_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, Mapped, _Alloc, splay_tree_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, null_type, _Alloc, cc_hash_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, null_type, _Alloc, gp_hash_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, null_type, _Alloc, list_update_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, null_type, _Alloc, ov_tree_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, null_type, _Alloc, pat_trie_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, null_type, _Alloc, rb_tree_tag, Policy_Tl > (__gnu_pbds::detail); container_base_dispatch< Key, null_type, _Alloc, splay_tree_tag, Policy_Tl > (__gnu_pbds::detail); container_error (__gnu_pbds); container_tag (__gnu_pbds); container_traits (__gnu_pbds); container_traits_base (__gnu_pbds); container_traits_base< binary_heap_tag > (__gnu_pbds); container_traits_base< binomial_heap_tag > (__gnu_pbds); container_traits_base< cc_hash_tag > (__gnu_pbds); container_traits_base< gp_hash_tag > (__gnu_pbds); container_traits_base< list_update_tag > (__gnu_pbds); container_traits_base< ov_tree_tag > (__gnu_pbds); container_traits_base< pairing_heap_tag > (__gnu_pbds); container_traits_base< pat_trie_tag > (__gnu_pbds); container_traits_base< rb_tree_tag > (__gnu_pbds); container_traits_base< rc_binomial_heap_tag > (__gnu_pbds); container_traits_base< splay_tree_tag > (__gnu_pbds); container_traits_base< thin_heap_tag > (__gnu_pbds); contiguous_iterator_tag (std); counted_iterator (std); ctype (std); ctype< char > (std); ctype< wchar_t > (std); ctype_base (std); ctype_byname (std); ctype_byname< char > (std)

D: dangling (std::ranges); debug_allocator (__gnu_cxx); decay (std); decimal128 (std::decimal); decimal32 (std::decimal); decimal64 (std::decimal); deduce (simd_abi); default_comb_hash_fn (__gnu_pbds::detail); default_delete (std); default_delete< _Tp[]> (std); default_eq_fn (__gnu_pbds::detail); default_hash_fn (__gnu_pbds::detail); default_parallel_tag (__gnu_parallel); default_probe_fn (__gnu_pbds::detail); default_resize_policy (__gnu_pbds::detail); default_sentinel_t (std); default_trie_access_traits (__gnu_pbds::detail); default_trie_access_traits< std::basic_string< Char, Char_Traits, std::allocator< char > > > (__gnu_pbds::detail); default_update_policy (__gnu_pbds::detail); defer_lock_t (std); deque (std::__debug); deque (std); destroying_delete_t (std); direct_bases (std::tr2); direct_mask_range_hashing (__gnu_pbds); direct_mod_range_hashing (__gnu_pbds); directory_entry (std::filesystem); directory_iterator (std::filesystem); discard_block_engine (std); discrete_distribution (std); divides (std); divides< void > (std); domain_error (std); dumnode_const_iterator (__gnu_pbds::detail); duration (std::chrono); duration_values (std::chrono); dynamic_bitset (std::tr2)

E: empty_view (std::ranges); enable_if (std); enable_shared_from_this (std); enc_filebuf (__gnu_cxx); encoding_char_traits (__gnu_cxx); encoding_state (__gnu_cxx); entry_cmp (__gnu_pbds::detail); entry_cmp< _VTp, Cmp_Fn, _Alloc, false > (__gnu_pbds::detail); entry_cmp< _VTp, Cmp_Fn, _Alloc, true > (__gnu_pbds::detail); entry_pred (__gnu_pbds::detail); entry_pred< _VTp, Pred, _Alloc, false > (__gnu_pbds::detail); entry_pred< _VTp, Pred, _Alloc, true > (__gnu_pbds::detail); eq_by_less (__gnu_pbds::detail); equal_split_tag (__gnu_parallel); equal_to (std); equal_to (std::ranges); equal_to< void > (std); error_category (std); error_code (std); error_condition (std); exact_tag (__gnu_parallel); exception (std); exception_ptr (std::__unspecified__); exponential_distribution (std); extent (std); extreme_value_distribution (std)

F: locale::facet (std); ios_base::failure (std); file_status (std::filesystem); filesystem_error (std::experimental::filesystem); filesystem_error (std::experimental::filesystem::v1); filesystem_error (std::filesystem); find_tag (__gnu_parallel); fisher_f_distribution (std); forced_error (__gnu_cxx); forward_iterator_tag (std); forward_list (std::__debug); forward_list (std); fpos (std); free_list (__gnu_cxx); from_chars_result (std); front_insert_iterator (std); function< _Res(_ArgTypes...)> (std); future (std); future< _Res & > (std); future< void > (std); future_error (std)

G: gamma_distribution (std); geometric_distribution (std); gp_hash_table (__gnu_pbds); gp_hash_tag (__gnu_pbds); gp_ht_map (__gnu_pbds::detail); greater (std); greater (std::ranges); greater< void > (std); greater_equal (std); greater_equal (std::ranges); greater_equal< void > (std); random_condition::group_adjustor (__gnu_cxx); growing_blocks_tag (__gnu_parallel); gslice (std); gslice_array (std)

H: has_unique_object_representations (std); has_virtual_destructor (std); hash (std); hash< __debug::bitset< _Nb > > (std); hash< __debug::vector< bool, _Alloc > > (std); hash< __gnu_cxx::__u16vstring > (std); hash< __gnu_cxx::__u32vstring > (std); hash< __gnu_cxx::__vstring > (std); hash< __gnu_cxx::__wvstring > (std); hash< __gnu_cxx::throw_value_limit > (std); hash< __gnu_cxx::throw_value_random > (std); hash< __gnu_debug::basic_string< _CharT > > (std); hash< __shared_ptr< _Tp, _Lp > > (std); hash< _Tp * > (std); hash< basic_string< char, char_traits< char >, _Alloc > > (std); hash< basic_string< char16_t, char_traits< char16_t >, _Alloc > > (std); hash< basic_string< char32_t, char_traits< char32_t >, _Alloc > > (std); hash< basic_string< wchar_t, char_traits< wchar_t >, _Alloc > > (std); hash< bool > (std); hash< char > (std); hash< char16_t > (std); hash< char32_t > (std); hash< double > (std); hash< error_code > (std); hash< error_condition > (std); hash< experimental::optional< _Tp > > (std); hash< experimental::shared_ptr< _Tp > > (std); hash< float > (std); hash< int > (std); hash< long > (std); hash< long double > (std); hash< long long > (std); hash< shared_ptr< _Tp > > (std); hash< short > (std); hash< signed char > (std); hash< thread::id > (std); hash< type_index > (std); hash< unique_ptr< _Tp, _Dp > > (std); hash< unsigned char > (std); hash< unsigned int > (std); hash< unsigned long > (std); hash< unsigned long long > (std); hash< unsigned short > (std); hash< wchar_t > (std); hash<::bitset< _Nb > > (std); hash<::vector< bool, _Alloc > > (std); hash_eq_fn (__gnu_pbds::detail); hash_eq_fn< Key, Eq_Fn, _Alloc, false > (__gnu_pbds::detail); hash_eq_fn< Key, Eq_Fn, _Alloc, true > (__gnu_pbds::detail); hash_exponential_size_policy (__gnu_pbds); hash_load_check_resize_trigger (__gnu_pbds); hash_load_check_resize_trigger_size_base (__gnu_pbds::detail); hash_load_check_resize_trigger_size_base< Size_Type, true > (__gnu_pbds::detail); hash_map (__gnu_cxx); hash_multimap (__gnu_cxx); hash_multiset (__gnu_cxx); hash_prime_size_policy (__gnu_pbds); hash_set (__gnu_cxx); hash_standard_resize_policy (__gnu_pbds)

I: thread::id (std); locale::id (std); identity (std); in_place_t (std::experimental::fundamentals_v1); in_place_t (std::experimental); independent_bits_engine (std); indirect_array (std); initializer_list (std); input_iterator_tag (std); insert_error (__gnu_pbds); insert_iterator (std); integer_sequence (std); integral_constant (std); invalid_argument (std); invoke_result (std); ios_base (std); is_abstract (std); is_aggregate (std); is_arithmetic (std); is_array (std); is_assignable (std); is_base_of (std); is_bind_expression (std); is_bind_expression< _Bind< _Signature > > (std); is_bind_expression< _Bind_result< _Result, _Signature > > (std); is_bind_expression< const _Bind< _Signature > > (std); is_bind_expression< const _Bind_result< _Result, _Signature > > (std); is_bind_expression< const volatile _Bind< _Signature > > (std); is_bind_expression< const volatile _Bind_result< _Result, _Signature > > (std); is_bind_expression< volatile _Bind< _Signature > > (std); is_bind_expression< volatile _Bind_result< _Result, _Signature > > (std); is_bounded_array (std); is_class (std); is_compound (std); is_const (std); is_constructible (std); is_copy_assignable (std); is_copy_constructible (std); is_default_constructible (std); is_destructible (std); is_empty (std); is_enum (std); is_error_code_enum (std); is_error_code_enum< future_errc > (std); is_error_condition_enum (std); is_final (std); is_floating_point (std); is_function (std); is_fundamental (std); is_integral (std); is_invocable (std); is_invocable_r (std); is_layout_compatible (std); is_literal_type (std); is_lvalue_reference (std); is_member_function_pointer (std); is_member_object_pointer (std); is_member_pointer (std); is_move_assignable (std); is_move_constructible (std); is_nothrow_assignable (std); is_nothrow_constructible (std); is_nothrow_convertible (std); is_nothrow_copy_assignable (std); is_nothrow_copy_constructible (std); is_nothrow_default_constructible (std); is_nothrow_destructible (std); is_nothrow_invocable (std); is_nothrow_invocable_r (std); is_nothrow_move_assignable (std); is_nothrow_move_constructible (std); is_nothrow_swappable (std); is_nothrow_swappable_with (std); is_null_pointer (std); is_object (std); is_placeholder (std); is_placeholder< _Placeholder< _Num > > (std); is_pod (std); is_pointer (std); is_pointer_interconvertible_base_of (std); is_polymorphic (std); is_reference (std); is_rvalue_reference (std); is_same (std); is_scalar (std); is_signed (std); is_standard_layout (std); is_swappable (std); is_swappable_with (std); is_trivial (std); is_trivially_assignable (std); is_trivially_constructible (std); is_trivially_copy_assignable (std); is_trivially_copy_constructible (std); is_trivially_copyable (std); is_trivially_default_constructible (std); is_trivially_destructible (std); is_trivially_move_assignable (std); is_trivially_move_constructible (std); is_unbounded_array (std); is_union (std); is_unsigned (std); is_void (std); is_volatile (std); istream_iterator (std); istreambuf_iterator (std); pat_trie_base::_Inode::iterator (__gnu_pbds::detail); path::iterator (std::experimental::filesystem::v1); path::iterator (std::filesystem); iterator (std); iterator_traits (std); iterator_traits< _Tp * > (std)

J: join_error (__gnu_pbds); jthread (std)

L: left_child_next_sibling_heap (__gnu_pbds::detail); left_child_next_sibling_heap_const_iterator_ (__gnu_pbds::detail); left_child_next_sibling_heap_node_ (__gnu_pbds::detail); left_child_next_sibling_heap_node_point_const_iterator_ (__gnu_pbds::detail); length_error (std); less (std); less (std::ranges); less< void > (std); less_equal (std); less_equal (std::ranges); less_equal< void > (std); limit_condition::limit_adjustor (__gnu_cxx); limit_condition (__gnu_cxx); linear_congruential_engine (std); linear_probe_fn (__gnu_pbds); list (std::__debug); list (std); list_update (__gnu_pbds); list_update_tag (__gnu_pbds); locale (std); lock_guard (std); logic_error (std); logical_and (std); logical_and< void > (std); logical_not (std); logical_not< void > (std); logical_or (std); logical_or< void > (std); lognormal_distribution (std); lu_counter_metadata (__gnu_pbds::detail); lu_counter_policy (__gnu_pbds); lu_counter_policy_base (__gnu_pbds::detail); lu_map (__gnu_pbds::detail); lu_move_to_front_policy (__gnu_pbds)

M: make_signed (std); make_unsigned (std); malloc_allocator (__gnu_cxx); map (std::__debug); map (std); mask_array (std); mask_based_range_hashing (__gnu_pbds::detail); match_results (std); maybe_null_type (__gnu_pbds::detail); maybe_null_type< Key, null_type, _Alloc, Store_Hash > (__gnu_pbds::detail); mem_fun1_ref_t (std); mem_fun1_t (std); mem_fun_ref_t (std); mem_fun_t (std); memory_resource (std::pmr); mersenne_twister_engine (std); messages (std); messages_base (std); messages_byname (std); minus (std); minus< void > (std); mod_based_range_hashing (__gnu_pbds::detail); modulus (std); modulus< void > (std); money_base (std); money_get (std); money_put (std); moneypunct (std); moneypunct_byname (std); move_iterator (std); move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)> (std); multimap (std::__debug); multimap (std); multiplies (std); multiplies< void > (std); multiset (std::__debug); multiset (std); multiway_mergesort_exact_tag (__gnu_parallel); multiway_mergesort_sampling_tag (__gnu_parallel); multiway_mergesort_tag (__gnu_parallel); mutex (std)

N: negate (std); negate< void > (std); negative_binomial_distribution (std); nested_exception (std); limit_condition::never_adjustor (__gnu_cxx); random_condition::never_adjustor (__gnu_cxx); new_allocator (__gnu_cxx); no_throw_copies (__gnu_pbds::detail); no_throw_copies< Key, null_type > (__gnu_pbds::detail); normal_distribution (std); nostopstate_t (std); not_equal_to (std::ranges); not_equal_to (std); not_equal_to< void > (std); null_node_update (__gnu_pbds); null_type (__gnu_pbds); nullopt_t (std::experimental::fundamentals_v1); nullopt_t (std::experimental); nullopt_t (std); num_get (std); num_put (std); numeric_limits (std); numeric_limits< bool > (std); numeric_limits< char > (std); numeric_limits< char16_t > (std); numeric_limits< char32_t > (std); numeric_limits< double > (std); numeric_limits< float > (std); numeric_limits< int > (std); numeric_limits< long > (std); numeric_limits< long double > (std); numeric_limits< long long > (std); numeric_limits< short > (std); numeric_limits< signed char > (std); numeric_limits< unsigned char > (std); numeric_limits< unsigned int > (std); numeric_limits< unsigned long > (std); numeric_limits< unsigned long long > (std); numeric_limits< unsigned short > (std); numeric_limits< wchar_t > (std); numpunct (std); numpunct_byname (std)

O: omp_loop_static_tag (__gnu_parallel); omp_loop_tag (__gnu_parallel); once_flag (std); optional (std::experimental::fundamentals_v1); optional (std::experimental); optional (std); ostream_iterator (std); ostream_joiner (std::experimental::fundamentals_v2); ostream_joiner (std::experimental); ostreambuf_iterator (std); out_of_range (std); output_iterator_tag (std); ov_tree_map (__gnu_pbds::detail); ov_tree_node_const_it_ (__gnu_pbds::detail); ov_tree_node_it_ (__gnu_pbds::detail); ov_tree_tag (__gnu_pbds); overflow_error (std); owner_less (std); owner_less< shared_ptr< _Tp > > (std::experimental::fundamentals_v2); owner_less< shared_ptr< _Tp > > (std::experimental); owner_less< shared_ptr< _Tp > > (std); owner_less< void > (std); owner_less< weak_ptr< _Tp > > (std::experimental::fundamentals_v2); owner_less< weak_ptr< _Tp > > (std::experimental); owner_less< weak_ptr< _Tp > > (std)

P: packaged_task< _Res(_ArgTypes...)> (std); pair (std); pairing_heap (__gnu_pbds::detail); pairing_heap_tag (__gnu_pbds); parallel_tag (__gnu_parallel); lognormal_distribution::param_type (std); weibull_distribution::param_type (std); uniform_real_distribution::param_type (std); uniform_int_distribution::param_type (std); student_t_distribution::param_type (std); poisson_distribution::param_type (std); piecewise_linear_distribution::param_type (std); piecewise_constant_distribution::param_type (std); normal_distribution::param_type (std); negative_binomial_distribution::param_type (std); geometric_distribution::param_type (std); gamma_distribution::param_type (std); fisher_f_distribution::param_type (std); extreme_value_distribution::param_type (std); exponential_distribution::param_type (std); discrete_distribution::param_type (std); chi_squared_distribution::param_type (std); cauchy_distribution::param_type (std); binomial_distribution::param_type (std); bernoulli_distribution::param_type (std); pat_trie_base (__gnu_pbds::detail); pat_trie_map (__gnu_pbds::detail); pat_trie_tag (__gnu_pbds); path (std::experimental::filesystem::v1); path (std::filesystem); path (std::experimental::filesystem); piecewise_constant_distribution (std); piecewise_construct_t (std); piecewise_linear_distribution (std); plus (std); point_invalidation_guarantee (__gnu_pbds); pointer_to_binary_function (std); pointer_to_unary_function (std); pointer_traits (std); pointer_traits< _Tp * > (std); poisson_distribution (std); pool_options (std::pmr); priority_queue (__gnu_pbds); priority_queue (std); priority_queue_tag (__gnu_pbds); probe_fn_base (__gnu_pbds::detail); project1st (__gnu_cxx); project2nd (__gnu_cxx); projected (std); promise (std); promise< _Res & > (std); promise< void > (std); propagate_const (std::experimental::fundamentals_v2); propagate_const (std::experimental)

Q: quadratic_probe_fn (__gnu_pbds); queue (std); quicksort_tag (__gnu_parallel)

R: random_access_iterator_tag (std); random_condition (__gnu_cxx); random_device (std); range_error (std); range_invalidation_guarantee (__gnu_pbds); ranged_hash_fn (__gnu_pbds::detail); ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, false > (__gnu_pbds::detail); ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, true > (__gnu_pbds::detail); ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, false > (__gnu_pbds::detail); ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, true > (__gnu_pbds::detail); ranged_probe_fn (__gnu_pbds::detail); ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, false > (__gnu_pbds::detail); ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, true > (__gnu_pbds::detail); ranged_probe_fn< Key, null_type, _Alloc, Comb_Probe_Fn, null_type, false > (__gnu_pbds::detail); rank (std); ratio (std); ratio_equal (std); ratio_greater (std); ratio_greater_equal (std); ratio_less (std); ratio_less_equal (std); ratio_not_equal (std); raw_storage_iterator (std); rb_tree (__gnu_cxx); rb_tree_map (__gnu_pbds::detail); rb_tree_node_ (__gnu_pbds::detail); rb_tree_tag (__gnu_pbds); rc (__gnu_pbds::detail); rc_binomial_heap (__gnu_pbds::detail); rc_binomial_heap_tag (__gnu_pbds); rebind_traits (__gnu_pbds::detail); recursive_directory_iterator (std::filesystem); recursive_init_error (__gnu_cxx); recursive_mutex (std); recursive_timed_mutex (std); bitset::reference (std); dynamic_bitset::reference (std::tr2); reference_wrapper (std); regex_error (std); regex_iterator (std); regex_token_iterator (std); regex_traits (std); remove_all_extents (std); remove_const (std); remove_cv (std); remove_extent (std); remove_pointer (std); remove_reference (std); remove_volatile (std); resize_error (__gnu_pbds); resize_policy (__gnu_pbds::detail); result_of (std); reverse_iterator (std); rope (__gnu_cxx); runtime_error (std)

S: sample_probe_fn (__gnu_pbds); sample_range_hashing (__gnu_pbds); sample_ranged_hash_fn (__gnu_pbds); sample_ranged_probe_fn (__gnu_pbds); sample_resize_policy (__gnu_pbds); sample_resize_trigger (__gnu_pbds); sample_size_policy (__gnu_pbds); sample_tree_node_update (__gnu_pbds); sample_trie_access_traits (__gnu_pbds); sample_trie_node_update (__gnu_pbds); sample_update_policy (__gnu_pbds); sampling_tag (__gnu_parallel); scoped_allocator_adaptor (std); scoped_lock (std); seed_seq (std); select1st (__gnu_cxx); select2nd (__gnu_cxx); select_value_type (__gnu_pbds::detail); select_value_type< Key, null_type > (__gnu_pbds::detail); basic_istream::sentry (std); basic_ostream::sentry (std); sequence_tag (__gnu_pbds); sequential_tag (__gnu_parallel); set (std::__debug); set (std); shared_future (std); shared_future< _Res & > (std); shared_future< void > (std); shared_lock (std); shared_mutex (std); shared_ptr (std); shared_timed_mutex (std); shuffle_order_engine (std); single_view (std::ranges); slice (std); slice_array (std); slist (__gnu_cxx); source_location (std); space_info (std::experimental::filesystem); space_info (std::experimental::filesystem::v1); space_info (std::filesystem); splay_tree_map (__gnu_pbds::detail); splay_tree_node_ (__gnu_pbds::detail); splay_tree_tag (__gnu_pbds); stack (std); stdio_filebuf (__gnu_cxx); stdio_sync_filebuf (__gnu_cxx); steady_clock (std::chrono); stop_callback (std); stop_source (std); stop_token (std); stored_data (__gnu_pbds::detail); stored_data< _Tv, _Th, false > (__gnu_pbds::detail); stored_hash (__gnu_pbds::detail); stored_value (__gnu_pbds::detail); string_tag (__gnu_pbds); student_t_distribution (std); sub_match (std); subrange (std::ranges); subtract_with_carry_engine (std); subtractive_rng (__gnu_cxx); synchronized_pool_resource (std::pmr); synth_access_traits (__gnu_pbds::detail); system_clock (std::chrono); system_error (std)

T: temporary_buffer (__gnu_cxx); thin_heap (__gnu_pbds::detail); thin_heap_tag (__gnu_pbds); thread (std); throw_allocator_base (__gnu_cxx); throw_allocator_limit (__gnu_cxx); throw_allocator_random (__gnu_cxx); throw_value_base (__gnu_cxx); throw_value_limit (__gnu_cxx); throw_value_random (__gnu_cxx); time_base (std); time_get (std); time_get_byname (std); time_point (std::chrono); time_put (std); time_put_byname (std); timed_mutex (std); to_chars_result (std); treat_as_floating_point (std::chrono); tree (__gnu_pbds); tree_metadata_helper (__gnu_pbds::detail); tree_metadata_helper< Node_Update, false > (__gnu_pbds::detail); tree_metadata_helper< Node_Update, true > (__gnu_pbds::detail); tree_node_metadata_dispatch (__gnu_pbds::detail); tree_order_statistics_node_update (__gnu_pbds); tree_tag (__gnu_pbds); tree_traits (__gnu_pbds::detail); tree_traits< Key, Mapped, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc > (__gnu_pbds::detail); tree_traits< Key, Mapped, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc > (__gnu_pbds::detail); tree_traits< Key, Mapped, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc > (__gnu_pbds::detail); tree_traits< Key, null_type, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc > (__gnu_pbds::detail); tree_traits< Key, null_type, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc > (__gnu_pbds::detail); tree_traits< Key, null_type, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc > (__gnu_pbds::detail); trie (__gnu_pbds); trie_metadata_helper (__gnu_pbds::detail); trie_metadata_helper< Node_Update, false > (__gnu_pbds::detail); trie_metadata_helper< Node_Update, true > (__gnu_pbds::detail); trie_node_metadata_dispatch (__gnu_pbds::detail); trie_order_statistics_node_update (__gnu_pbds); trie_policy_base (__gnu_pbds::detail); trie_prefix_search_node_update (__gnu_pbds); trie_string_access_traits (__gnu_pbds); trie_tag (__gnu_pbds); trie_traits (__gnu_pbds::detail); trie_traits< Key, Mapped, _ATraits, Node_Update, pat_trie_tag, _Alloc > (__gnu_pbds::detail); trie_traits< Key, null_type, _ATraits, Node_Update, pat_trie_tag, _Alloc > (__gnu_pbds::detail); trivial_iterator_tag (__gnu_pbds); try_to_lock_t (std); tuple (std); tuple< _T1, _T2 > (std); tuple_element (std); tuple_element< 0, pair< _Tp1, _Tp2 > > (std); tuple_element< 1, pair< _Tp1, _Tp2 > > (std); tuple_element< __i, tuple< _Types... > > (std); tuple_element< _Ind, array< _Tp, _Nm > > (std); tuple_size (std); tuple_size< array< _Tp, _Nm > > (std); tuple_size< pair< _Tp1, _Tp2 > > (std); tuple_size< tuple< _Elements... > > (std); entry_cmp< _VTp, Cmp_Fn, _Alloc, false >::type (__gnu_pbds::detail); type_index (std); type_info (std); types_traits (__gnu_pbds::detail)

V: valarray (std); vector (std::__debug); vector (std); vector< bool, _Alloc > (std); view_base (std::ranges); view_interface (std::ranges)

W: wbuffer_convert (std); weak_ptr (std); weibull_distribution (std); wstring_convert (std)

_: __accumulate_binop_reduct (__gnu_parallel); __accumulate_selector (__gnu_parallel); __adjacent_difference_selector (__gnu_parallel); __adjacent_find_selector (__gnu_parallel); __alloc_traits (__gnu_cxx); __basic_future (std); __binder1st (__gnu_parallel); __binder2nd (__gnu_parallel); __codecvt_abstract_base (std); __common_pool_policy (__gnu_cxx); __count_if_selector (__gnu_parallel); __count_selector (__gnu_parallel); __ctype_abstract_base (std); __directory_iterator_proxy (std::filesystem); __dynamic_bitset_base (std::tr2); __fill_selector (__gnu_parallel); __find_first_of_selector (__gnu_parallel); __find_if_selector (__gnu_parallel); __for_each_selector (__gnu_parallel); __forced_unwind (__cxxabiv1); __generate_selector (__gnu_parallel); __generic_find_selector (__gnu_parallel); __generic_for_each_selector (__gnu_parallel); __identity_selector (__gnu_parallel); __inner_product_selector (__gnu_parallel); __is_fast_hash (std); __is_location_invariant (std); __is_nullptr_t (std); __max_element_reduct (__gnu_parallel); __min_element_reduct (__gnu_parallel); __mini_vector (__gnu_cxx::__detail); __mismatch_selector (__gnu_parallel); __mt_alloc (__gnu_cxx); __mt_alloc_base (__gnu_cxx); __multiway_merge_3_variant_sentinel_switch (__gnu_parallel); __multiway_merge_3_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > (__gnu_parallel); __multiway_merge_4_variant_sentinel_switch (__gnu_parallel); __multiway_merge_4_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > (__gnu_parallel); __multiway_merge_k_variant_sentinel_switch (__gnu_parallel); __multiway_merge_k_variant_sentinel_switch< false, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare > (__gnu_parallel); __new_allocator (std); __numeric_limits_base (std); __per_type_pool_policy (__gnu_cxx); __pool (__gnu_cxx); __pool< false > (__gnu_cxx); __pool< true > (__gnu_cxx); __pool_alloc (__gnu_cxx); __pool_alloc_base (__gnu_cxx); __pool_base (__gnu_cxx); __rc_string_base (__gnu_cxx); __reflection_typelist (std::tr2); __reflection_typelist< _First, _Rest... > (std::tr2); __reflection_typelist<> (std::tr2); __replace_if_selector (__gnu_parallel); __replace_selector (__gnu_parallel); __scoped_lock (__gnu_cxx); __transform1_selector (__gnu_parallel); __transform2_selector (__gnu_parallel); __unary_negate (__gnu_parallel); __versa_string (__gnu_cxx); _After_nth_from (__gnu_debug); _Base_bitset (std); _Base_bitset< 0 > (std); _Base_bitset< 1 > (std); _BeforeBeginHelper (__gnu_debug); _Bind (std); _Bind_result (std); _Bitmap_counter (__gnu_cxx::__detail); _BracketMatcher (std::__detail); _Caster (__gnu_cxx); _Char_types (__gnu_cxx); pat_trie_base::_CIter (__gnu_pbds::detail); _Compiler (std::__detail); _CRandNumber (std::__parallel); _Deque_base (std); _Deque_iterator (std); _DRandomShufflingGlobalData (__gnu_parallel); _DRSSorterPU (__gnu_parallel); _DummyReduct (__gnu_parallel); _Equal_to (__gnu_debug); _EqualFromLess (__gnu_parallel); _EqualTo (__gnu_parallel); _Executor (std::__detail); _ExtPtr_allocator (__gnu_cxx); _Ffit_finder (__gnu_cxx::__detail); _Function_base (std); _Fwd_list_base (std); _Fwd_list_const_iterator (std); _Fwd_list_iterator (std); _Fwd_list_node (std); _Fwd_list_node_base (std); _GuardedIterator (__gnu_parallel); pat_trie_base::_Head (__gnu_pbds::detail); pat_trie_base::_Inode (__gnu_pbds::detail); _Invalid_type (__gnu_cxx); pat_trie_base::_Iter (__gnu_pbds::detail); _IteratorPair (__gnu_parallel); _IteratorTriple (__gnu_parallel); _Job (__gnu_parallel); pat_trie_base::_Leaf (__gnu_pbds::detail); _Less (__gnu_parallel); _Lexicographic (__gnu_parallel); _LexicographicReverse (__gnu_parallel); _List_base (std); _List_const_iterator (std); _List_iterator (std); _List_node (std); _List_node_base (std::__detail); _List_node_header (std::__detail); _LoserTreeBase::_Loser (__gnu_parallel); _LoserTreePointerBase::_Loser (__gnu_parallel); _LoserTree (__gnu_parallel); _LoserTree< false, _Tp, _Compare > (__gnu_parallel); _LoserTreeBase (__gnu_parallel); _LoserTreePointer (__gnu_parallel); _LoserTreePointer< false, _Tp, _Compare > (__gnu_parallel); _LoserTreePointerBase (__gnu_parallel); _LoserTreePointerUnguarded (__gnu_parallel); _LoserTreePointerUnguarded< false, _Tp, _Compare > (__gnu_parallel); _LoserTreePointerUnguardedBase (__gnu_parallel); _LoserTreeTraits (__gnu_parallel); _LoserTreeUnguarded (__gnu_parallel); _LoserTreeUnguarded< false, _Tp, _Compare > (__gnu_parallel); _LoserTreeUnguardedBase (__gnu_parallel); pat_trie_base::_Metadata (__gnu_pbds::detail); pat_trie_base::_Metadata< null_type, _Alloc > (__gnu_pbds::detail); _Multiplies (__gnu_parallel); pat_trie_base::_Node_base (__gnu_pbds::detail); pat_trie_base::_Node_citer (__gnu_pbds::detail); _Node_handle (std); _Node_handle< _Value, _Value, _NodeAlloc > (std); _Node_handle_common (std); _Node_insert_return (std); pat_trie_base::_Node_iter (__gnu_pbds::detail); _Not_equal_to (__gnu_debug); _Not_fn (std); _Nothing (__gnu_parallel); _Optional_base (std); _Piece (__gnu_parallel); _Placeholder (std); _Plus (__gnu_parallel); _PMWMSSortingData (__gnu_parallel); _Pointer_adapter (__gnu_cxx); _PseudoSequence (__gnu_parallel); _PseudoSequenceIterator (__gnu_parallel); _QSBThreadLocal (__gnu_parallel); _Quoted_string (std::__detail); _RandomNumber (__gnu_parallel); _Relative_pointer_impl (__gnu_cxx); _Relative_pointer_impl< const _Tp > (__gnu_cxx); _RestrictedBoundedConcurrentQueue (__gnu_parallel); _Safe_container (__gnu_debug); _Safe_forward_list (__gnu_debug); _Safe_iterator (__gnu_debug); _Safe_iterator_base (__gnu_debug); _Safe_local_iterator (__gnu_debug); _Safe_local_iterator_base (__gnu_debug); _Safe_node_sequence (__gnu_debug); _Safe_sequence (__gnu_debug); _Safe_sequence_base (__gnu_debug); _Safe_unordered_container (__gnu_debug); _Safe_unordered_container_base (__gnu_debug); _Safe_vector (__gnu_debug); _SamplingSorter (__gnu_parallel); _SamplingSorter< false, _RAIter, _StrictWeakOrdering > (__gnu_parallel); _Scanner (std::__detail); _Sequence_traits (__gnu_debug); _Settings (__gnu_parallel); _Sp_ebo_helper< _Nm, _Tp, false > (std); _Sp_ebo_helper< _Nm, _Tp, true > (std); _SplitConsistently (__gnu_parallel); _SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator > (__gnu_parallel); _SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator > (__gnu_parallel); _StateSeq (std::__detail); _Std_pointer_impl (__gnu_cxx); _Temporary_buffer (std); _Tuple_impl (std); _Tuple_impl< _Idx, _Head, _Tail... > (std); _Unqualified_type (__gnu_cxx); _Vector_base (std)