libstdc++
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 Cstd::__add_pointer_helper< _Tp >
 Cstd::__atomic_base< _Tp * >
 Cstd::__atomic_base< bool >
 Cstd::__atomic_base< char >
 Cstd::atomic< char >Explicit specialization for char
 Cstd::__atomic_base< char16_t >
 Cstd::atomic< char16_t >Explicit specialization for char16_t
 Cstd::__atomic_base< char32_t >
 Cstd::atomic< char32_t >Explicit specialization for char32_t
 Cstd::__atomic_base< int >
 Cstd::atomic< int >Explicit specialization for int
 Cstd::__atomic_base< long >
 Cstd::atomic< long >Explicit specialization for long
 Cstd::__atomic_base< long long >
 Cstd::atomic< long long >Explicit specialization for long long
 Cstd::__atomic_base< short >
 Cstd::atomic< short >Explicit specialization for short
 Cstd::__atomic_base< signed char >
 Cstd::atomic< signed char >Explicit specialization for signed char
 Cstd::__atomic_base< unsigned char >
 Cstd::atomic< unsigned char >Explicit specialization for unsigned char
 Cstd::__atomic_base< unsigned int >
 Cstd::atomic< unsigned int >Explicit specialization for unsigned int
 Cstd::__atomic_base< unsigned long >
 Cstd::atomic< unsigned long >Explicit specialization for unsigned long
 Cstd::__atomic_base< unsigned long long >
 Cstd::atomic< unsigned long long >Explicit specialization for unsigned long long
 Cstd::__atomic_base< unsigned short >
 Cstd::atomic< unsigned short >Explicit specialization for unsigned short
 Cstd::__atomic_base< wchar_t >
 Cstd::atomic< wchar_t >Explicit specialization for wchar_t
 C__cxxabiv1::__forced_unwindThrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recognize forced unwinding
 C__gnu_cxx::__common_pool_policy< _PoolTp, _Thread >Policy for shared __pool objects
 C__gnu_cxx::__detail::__mini_vector< _Tp >__mini_vector<> is a stripped down version of the full-fledged std::vector<>
 C__gnu_cxx::__detail::_Bitmap_counter< _Tp >The bitmap counter which acts as the bitmap manipulator, and manages the bit-manipulation functions and the searching and identification functions on the bit-map
 C__gnu_cxx::__mt_alloc_base< _Tp >Base class for _Tp dependent member functions
 C__gnu_cxx::__mt_alloc< _Tp, _Poolp >This is a fixed size (power of 2) allocator which - when compiled with thread support - will maintain one freelist per size per thread plus a global one. Steps are taken to limit the per thread freelist sizes (by returning excess back to the global list).Further details: https://gcc.gnu.org/onlinedocs/libstdc++/manual/mt_allocator.html
 C__gnu_cxx::__per_type_pool_policy< _Tp, _PoolTp, _Thread >Policy for individual __pool objects
 C__gnu_cxx::__pool< _Thread >Data describing the underlying memory pool, parameterized on threading support
 C__gnu_cxx::__pool_alloc_baseBase class for __pool_alloc
 C__gnu_cxx::__pool_alloc< _Tp >Allocator using a memory pool with a single lock
 C__gnu_cxx::__pool_baseBase class for pool object
 C__gnu_cxx::__pool< false >Specialization for single thread
 C__gnu_cxx::__pool< true >Specialization for thread enabled, via gthreads.h
 C__gnu_cxx::__rc_string_base< _CharT, _Traits, _Alloc >
 C__gnu_cxx::__scoped_lockScoped lock idiom
 C__gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, _Base >Template class __versa_string.Data structure managing sequences of characters and character-like objects
 C__gnu_cxx::_Caster< _ToType >
 C__gnu_cxx::_Char_types< _CharT >Mapping from character type to associated types
 C__gnu_cxx::_ExtPtr_allocator< _Tp >An example allocator which uses a non-standard pointer type.This allocator specifies that containers use a 'relative pointer' as it's pointer type. (See ext/pointer.h) Memory allocation in this example is still performed using std::allocator
 C__gnu_cxx::_Invalid_type
 C__gnu_cxx::_Pointer_adapter< _Storage_policy >
 C__gnu_cxx::_Relative_pointer_impl< _Tp >A storage policy for use with _Pointer_adapter<> which stores the pointer's address as an offset value which is relative to its own address
 C__gnu_cxx::_Relative_pointer_impl< const _Tp >
 C__gnu_cxx::_Std_pointer_impl< _Tp >A storage policy for use with _Pointer_adapter<> which yields a standard pointer
 C__gnu_cxx::_Unqualified_type< _Tp >
 C__gnu_cxx::annotate_baseBase class for checking address and label information about allocations. Create a std::map between the allocated address (void*) and a datum for annotations, which are a pair of numbers corresponding to label and allocated size
 C__gnu_cxx::throw_allocator_base< _Tp, _Cond >Allocator class with logging and exception generation control. Intended to be used as an allocator_type in templatized code.Note: Deallocate not allowed to throw
 C__gnu_cxx::throw_allocator_base< _Tp, limit_condition >
 C__gnu_cxx::throw_allocator_limit< _Tp >Allocator throwing via limit condition
 C__gnu_cxx::throw_allocator_base< _Tp, random_condition >
 C__gnu_cxx::throw_allocator_random< _Tp >Allocator throwing via random condition
 C__gnu_cxx::array_allocator_base< _Tp >Base class
 C__gnu_cxx::array_allocator< _Tp, _Array >An allocator that uses previously allocated memory. This memory can be externally, globally, or otherwise allocated
 C__gnu_cxx::char_traits< _CharT >Base class used to implement std::char_traits
 Cstd::char_traits< _CharT >Basis for explicit traits specializations
 C__gnu_cxx::encoding_char_traits< _CharT >Encoding_char_traits
 C__gnu_cxx::character< _Value, _Int, _St >A POD class that serves as a character abstraction class
 C__gnu_cxx::condition_baseBase struct for condition policy
 C__gnu_cxx::limit_conditionBase class for incremental control and throw
 C__gnu_cxx::throw_allocator_base< _Tp, limit_condition >
 C__gnu_cxx::throw_value_base< limit_condition >
 C__gnu_cxx::throw_value_limitType throwing via limit condition
 C__gnu_cxx::random_conditionBase class for random probability control and throw
 C__gnu_cxx::throw_allocator_base< _Tp, random_condition >
 C__gnu_cxx::throw_value_base< random_condition >
 C__gnu_cxx::throw_value_randomType throwing via random condition
 C__gnu_cxx::constant_binary_fun< _Result, _Arg1, _Arg2 >An SGI extension
 C__gnu_cxx::constant_unary_fun< _Result, _Argument >An SGI extension
 C__gnu_cxx::constant_void_fun< _Result >An SGI extension
 C__gnu_cxx::debug_allocator< _Alloc >A meta-allocator with debugging bits.This is precisely the allocator defined in the C++03 Standard
 C__gnu_cxx::encoding_stateExtension to use iconv for dealing with character encodings
 C__gnu_cxx::free_listThe free list class for managing chunks of memory to be given to and returned by the bitmap_allocator
 C__gnu_cxx::bitmap_allocator< _Tp >Bitmap Allocator, primary template
 C__gnu_cxx::hash_map< _Key, _Tp, _HashFn, _EqualKey, _Alloc >
 C__gnu_cxx::hash_multimap< _Key, _Tp, _HashFn, _EqualKey, _Alloc >
 C__gnu_cxx::hash_multiset< _Value, _HashFcn, _EqualKey, _Alloc >
 C__gnu_cxx::hash_set< _Value, _HashFcn, _EqualKey, _Alloc >
 C__gnu_cxx::limit_condition::always_adjustorAlways enter the condition
 C__gnu_cxx::limit_condition::limit_adjustorEnter the nth condition
 C__gnu_cxx::limit_condition::never_adjustorNever enter the condition
 C__gnu_cxx::malloc_allocator< _Tp >An allocator that uses malloc.This is precisely the allocator defined in the C++ Standard
 C__gnu_cxx::new_allocator< _Tp >An allocator that uses global new, as per [20.4].This is precisely the allocator defined in the C++ Standard
 Cstd::allocator< value_type >
 Cstd::allocator< _Tp >The standard allocator, as per [20.4]
 C__gnu_cxx::project1st< _Arg1, _Arg2 >An SGI extension
 C__gnu_cxx::project2nd< _Arg1, _Arg2 >An SGI extension
 C__gnu_cxx::random_condition::always_adjustorAlways enter the condition
 C__gnu_cxx::random_condition::group_adjustorGroup condition
 C__gnu_cxx::random_condition::never_adjustorNever enter the condition
 C__gnu_cxx::rb_tree< _Key, _Value, _KeyOfValue, _Compare, _Alloc >
 C__gnu_cxx::rope< _CharT, _Alloc >
 C__gnu_cxx::select1st< _Pair >An SGI extension
 C__gnu_cxx::select2nd< _Pair >An SGI extension
 C__gnu_cxx::slist< _Tp, _Alloc >
 C__gnu_cxx::throw_value_base< _Cond >Class with exception generation control. Intended to be used as a value_type in templatized code
 C__gnu_debug::_After_nth_from< _Iterator >
 C__gnu_debug::_BeforeBeginHelper< _Sequence >
 C__gnu_debug::_Equal_to< _Type >
 C__gnu_debug::_Not_equal_to< _Type >
 C__gnu_debug::_Safe_container< _SafeContainer, _Alloc, _SafeBase, _IsCxx11AllocatorAware >Safe class dealing with some allocator dependent operations
 C__gnu_debug::_Safe_iterator_baseBasic functionality for a safe iterator
 C__gnu_debug::_Safe_iterator< _Iterator, _Sequence >Safe iterator wrapper
 C__gnu_debug::_Safe_local_iterator_baseBasic functionality for a safe iterator
 C__gnu_debug::_Safe_local_iterator< _Iterator, _Sequence >Safe iterator wrapper
 C__gnu_debug::_Safe_sequence_baseBase class that supports tracking of iterators that reference a sequence
 C__gnu_debug::_Safe_sequence< _Sequence >Base class for constructing a safe sequence type that tracks iterators that reference it
 C__gnu_debug::_Safe_node_sequence< _Sequence >Like _Safe_sequence but with a special _M_invalidate_all implementation not invalidating past-the-end iterators. Used by node based sequence
 C__gnu_debug::_Safe_unordered_container_baseBase class that supports tracking of local iterators that reference an unordered container
 C__gnu_debug::_Safe_unordered_container< _Container >Base class for constructing a safe unordered container type that tracks iterators that reference it
 C__gnu_debug::_Safe_unordered_container< unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc > >
 C__gnu_debug::_Safe_container< unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >, _Alloc, __gnu_debug::_Safe_unordered_container >
 Cstd::__debug::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_map with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_unordered_container< unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc > >
 C__gnu_debug::_Safe_container< unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >, _Alloc, __gnu_debug::_Safe_unordered_container >
 Cstd::__debug::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_multimap with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_unordered_container< unordered_multiset< _Value, _Hash, _Pred, _Alloc > >
 C__gnu_debug::_Safe_container< unordered_multiset< _Value, _Hash, _Pred, _Alloc >, _Alloc, __gnu_debug::_Safe_unordered_container >
 Cstd::__debug::unordered_multiset< _Value, _Hash, _Pred, _Alloc >Class std::unordered_multiset with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_unordered_container< unordered_set< _Value, _Hash, _Pred, _Alloc > >
 C__gnu_debug::_Safe_container< unordered_set< _Value, _Hash, _Pred, _Alloc >, _Alloc, __gnu_debug::_Safe_unordered_container >
 Cstd::__debug::unordered_set< _Value, _Hash, _Pred, _Alloc >Class std::unordered_set with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_sequence< _SafeSequence >
 C__gnu_debug::_Safe_forward_list< _SafeSequence >Special iterators swap and invalidation for forward_list because of the before_begin iterator
 C__gnu_debug::_Safe_sequence< basic_string< _CharT, _Traits, _Allocator > >
 C__gnu_debug::_Safe_container< basic_string< _CharT, _Traits, _Allocator >, _Allocator, _Safe_sequence, bool(_GLIBCXX_USE_CXX11_ABI)>
 C__gnu_debug::basic_string< _CharT, _Traits, _Allocator >Class std::basic_string with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_sequence< deque< _Tp, _Allocator > >
 C__gnu_debug::_Safe_container< deque< _Tp, _Allocator >, _Allocator, __gnu_debug::_Safe_sequence >
 Cstd::__debug::deque< _Tp, _Allocator >Class std::deque with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_sequence< forward_list< _Tp, _Alloc > >
 C__gnu_debug::_Safe_forward_list< forward_list< _Tp, _Alloc > >
 C__gnu_debug::_Safe_container< forward_list< _Tp, _Alloc >, _Alloc, __gnu_debug::_Safe_forward_list >
 Cstd::__debug::forward_list< _Tp, _Alloc >Class std::forward_list with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_sequence< list< _Tp, _Allocator > >
 C__gnu_debug::_Safe_node_sequence< list< _Tp, _Allocator > >
 C__gnu_debug::_Safe_container< list< _Tp, _Allocator >, _Allocator, __gnu_debug::_Safe_node_sequence >
 Cstd::__debug::list< _Tp, _Allocator >Class std::list with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_sequence< map< _Key, _Tp, _Compare, _Allocator > >
 C__gnu_debug::_Safe_node_sequence< map< _Key, _Tp, _Compare, _Allocator > >
 C__gnu_debug::_Safe_container< map< _Key, _Tp, _Compare, _Allocator >, _Allocator, __gnu_debug::_Safe_node_sequence >
 Cstd::__debug::map< _Key, _Tp, _Compare, _Allocator >Class std::map with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_sequence< multimap< _Key, _Tp, _Compare, _Allocator > >
 C__gnu_debug::_Safe_node_sequence< multimap< _Key, _Tp, _Compare, _Allocator > >
 C__gnu_debug::_Safe_container< multimap< _Key, _Tp, _Compare, _Allocator >, _Allocator, __gnu_debug::_Safe_node_sequence >
 Cstd::__debug::multimap< _Key, _Tp, _Compare, _Allocator >Class std::multimap with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_sequence< multiset< _Key, _Compare, _Allocator > >
 C__gnu_debug::_Safe_node_sequence< multiset< _Key, _Compare, _Allocator > >
 C__gnu_debug::_Safe_container< multiset< _Key, _Compare, _Allocator >, _Allocator, __gnu_debug::_Safe_node_sequence >
 Cstd::__debug::multiset< _Key, _Compare, _Allocator >Class std::multiset with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_sequence< set< _Key, _Compare, _Allocator > >
 C__gnu_debug::_Safe_node_sequence< set< _Key, _Compare, _Allocator > >
 C__gnu_debug::_Safe_container< set< _Key, _Compare, _Allocator >, _Allocator, __gnu_debug::_Safe_node_sequence >
 Cstd::__debug::set< _Key, _Compare, _Allocator >Class std::set with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_sequence< vector< _Tp, _Allocator > >
 C__gnu_debug::_Safe_container< vector< _Tp, _Allocator >, _Allocator, __gnu_debug::_Safe_sequence >
 Cstd::__debug::vector< _Tp, _Allocator >Class std::vector with safety/checking/debug instrumentation
 C__gnu_debug::_Safe_vector< _SafeSequence, _BaseSequence >Base class for Debug Mode vector
 C__gnu_debug::_Sequence_traits< _Sequence >
 C__gnu_parallel::__accumulate_binop_reduct< _BinOp >General reduction, using a binary operator
 C__gnu_parallel::__generic_find_selectorBase class of all __gnu_parallel::__find_template selectors
 C__gnu_parallel::__adjacent_find_selectorTest predicate on two adjacent elements
 C__gnu_parallel::__find_first_of_selector< _FIterator >Test predicate on several elements
 C__gnu_parallel::__find_if_selectorTest predicate on a single element, used for std::find() and std::find_if ()
 C__gnu_parallel::__mismatch_selectorTest inverted predicate on a single element
 C__gnu_parallel::__generic_for_each_selector< _It >Generic __selector for embarrassingly parallel functions
 C__gnu_parallel::__accumulate_selector< _It >Std::accumulate() selector
 C__gnu_parallel::__adjacent_difference_selector< _It >Selector that returns the difference between two adjacent __elements
 C__gnu_parallel::__count_if_selector< _It, _Diff >Std::count_if () selector
 C__gnu_parallel::__count_selector< _It, _Diff >Std::count() selector
 C__gnu_parallel::__fill_selector< _It >Std::fill() selector
 C__gnu_parallel::__for_each_selector< _It >Std::for_each() selector
 C__gnu_parallel::__generate_selector< _It >Std::generate() selector
 C__gnu_parallel::__identity_selector< _It >Selector that just returns the passed iterator
 C__gnu_parallel::__inner_product_selector< _It, _It2, _Tp >Std::inner_product() selector
 C__gnu_parallel::__replace_if_selector< _It, _Op, _Tp >Std::replace() selector
 C__gnu_parallel::__replace_selector< _It, _Tp >Std::replace() selector
 C__gnu_parallel::__transform1_selector< _It >Std::transform() __selector, one input sequence variant
 C__gnu_parallel::__transform2_selector< _It >Std::transform() __selector, two input sequences variant
 C__gnu_parallel::__max_element_reduct< _Compare, _It >Reduction for finding the maximum element, using a comparator
 C__gnu_parallel::__min_element_reduct< _Compare, _It >Reduction for finding the maximum element, using a comparator
 C__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 3-way merging with __sentinels turned off
 C__gnu_parallel::__multiway_merge_3_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 3-way merging with __sentinels turned on
 C__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< __sentinels, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 4-way merging with __sentinels turned off
 C__gnu_parallel::__multiway_merge_4_variant_sentinel_switch< true, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for 4-way merging with __sentinels turned on
 C__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< __sentinels, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for k-way merging with __sentinels turned on
 C__gnu_parallel::__multiway_merge_k_variant_sentinel_switch< false, __stable, _RAIterIterator, _RAIter3, _DifferenceTp, _Compare >Switch for k-way merging with __sentinels turned off
 C__gnu_parallel::_DRandomShufflingGlobalData< _RAIter >Data known to every thread participating in __gnu_parallel::__parallel_random_shuffle()
 C__gnu_parallel::_DRSSorterPU< _RAIter, _RandomNumberGenerator >Local data for a thread participating in __gnu_parallel::__parallel_random_shuffle()
 C__gnu_parallel::_DummyReductReduction function doing nothing
 C__gnu_parallel::_GuardedIterator< _RAIter, _Compare >_Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
 C__gnu_parallel::_IteratorTriple< _Iterator1, _Iterator2, _Iterator3, _IteratorCategory >A triple of iterators. The usual iterator operations are applied to all three child iterators
 C__gnu_parallel::_Job< _DifferenceTp >One __job for a certain thread
 C__gnu_parallel::_LoserTreeBase< _Tp, _Compare >Guarded loser/tournament tree
 C__gnu_parallel::_LoserTree< __stable, _Tp, _Compare >Stable _LoserTree variant
 C__gnu_parallel::_LoserTree< false, _Tp, _Compare >Unstable _LoserTree variant
 C__gnu_parallel::_LoserTreeBase< _Tp, _Compare >::_LoserInternal representation of a _LoserTree element
 C__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >Base class of _Loser Tree implementation using pointers
 C__gnu_parallel::_LoserTreePointer< __stable, _Tp, _Compare >Stable _LoserTree implementation
 C__gnu_parallel::_LoserTreePointer< false, _Tp, _Compare >Unstable _LoserTree implementation
 C__gnu_parallel::_LoserTreePointerBase< _Tp, _Compare >::_LoserInternal representation of _LoserTree __elements
 C__gnu_parallel::_LoserTreePointerUnguardedBase< _Tp, _Compare >Unguarded loser tree, keeping only pointers to the elements in the tree structure
 C__gnu_parallel::_LoserTreePointerUnguarded< __stable, _Tp, _Compare >Stable unguarded _LoserTree variant storing pointers
 C__gnu_parallel::_LoserTreePointerUnguarded< false, _Tp, _Compare >Unstable unguarded _LoserTree variant storing pointers
 C__gnu_parallel::_LoserTreeTraits< _Tp >Traits for determining whether the loser tree should use pointers or copies
 C__gnu_parallel::_LoserTreeUnguardedBase< _Tp, _Compare >Base class for unguarded _LoserTree implementation
 C__gnu_parallel::_LoserTreeUnguarded< __stable, _Tp, _Compare >Stable implementation of unguarded _LoserTree
 C__gnu_parallel::_LoserTreeUnguarded< false, _Tp, _Compare >Non-Stable implementation of unguarded _LoserTree
 C__gnu_parallel::_NothingFunctor doing nothing
 C__gnu_parallel::_Piece< _DifferenceTp >Subsequence description
 C__gnu_parallel::_PMWMSSortingData< _RAIter >Data accessed by all threads
 C__gnu_parallel::_PseudoSequence< _Tp, _DifferenceTp >Sequence that conceptually consists of multiple copies of the same element. The copies are not stored explicitly, of course
 C__gnu_parallel::_PseudoSequenceIterator< _Tp, _DifferenceTp >_Iterator associated with __gnu_parallel::_PseudoSequence. If features the usual random-access iterator functionality
 C__gnu_parallel::_QSBThreadLocal< _RAIter >Information local to one thread in the parallel quicksort run
 C__gnu_parallel::_RandomNumberRandom number generator, based on the Mersenne twister
 C__gnu_parallel::_RestrictedBoundedConcurrentQueue< _Tp >Double-ended queue of bounded size, allowing lock-free atomic access. push_front() and pop_front() must not be called concurrently to each other, while pop_back() can be called concurrently at all times. empty(), size(), and top() are intentionally not provided. Calling them would not make sense in a concurrent setting
 C__gnu_parallel::_SamplingSorter< __stable, _RAIter, _StrictWeakOrdering >Stable sorting functor
 C__gnu_parallel::_SamplingSorter< false, _RAIter, _StrictWeakOrdering >Non-__stable sorting functor
 C__gnu_parallel::_SettingsClass _Settings Run-time settings for the parallel mode including all tunable parameters
 C__gnu_parallel::_SplitConsistently< __exact, _RAIter, _Compare, _SortingPlacesIterator >Split consistently
 C__gnu_parallel::_SplitConsistently< false, _RAIter, _Compare, _SortingPlacesIterator >Split by sampling
 C__gnu_parallel::_SplitConsistently< true, _RAIter, _Compare, _SortingPlacesIterator >Split by exact splitting
 C__gnu_parallel::find_tagBase class for for std::find() variants
 C__gnu_parallel::constant_size_blocks_tagSelects the constant block size variant for std::find()
 C__gnu_parallel::equal_split_tagSelects the equal splitting variant for std::find()
 C__gnu_parallel::growing_blocks_tagSelects the growing block size variant for std::find()
 C__gnu_parallel::parallel_tagRecommends parallel execution at compile time, optionally using a user-specified number of threads
 C__gnu_parallel::balanced_quicksort_tagForces parallel sorting using balanced quicksort at compile time
 C__gnu_parallel::balanced_tagRecommends parallel execution using dynamic load-balancing at compile time
 C__gnu_parallel::default_parallel_tagRecommends parallel execution using the default parallel algorithm
 C__gnu_parallel::exact_tagForces parallel merging with exact splitting, at compile time
 C__gnu_parallel::multiway_mergesort_exact_tagForces parallel sorting using multiway mergesort with exact splitting at compile time
 C__gnu_parallel::multiway_mergesort_sampling_tagForces parallel sorting using multiway mergesort with splitting by sampling at compile time
 C__gnu_parallel::multiway_mergesort_tagForces parallel sorting using multiway mergesort at compile time
 C__gnu_parallel::omp_loop_static_tagRecommends parallel execution using OpenMP static load-balancing at compile time
 C__gnu_parallel::omp_loop_tagRecommends parallel execution using OpenMP dynamic load-balancing at compile time
 C__gnu_parallel::quicksort_tagForces parallel sorting using unbalanced quicksort at compile time
 C__gnu_parallel::sampling_tagForces parallel merging with exact splitting, at compile time
 C__gnu_parallel::unbalanced_tagRecommends parallel execution using static load-balancing at compile time
 C__gnu_parallel::sequential_tagForces sequential execution at compile time
 C__gnu_pbds::basic_branch< Key, Mapped, Tag, Node_Update, Policy_Tl, _Alloc >
 C__gnu_pbds::basic_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, Tag, Policy_Tl, _Alloc >
 C__gnu_pbds::basic_invalidation_guarantee
 C__gnu_pbds::point_invalidation_guarantee
 C__gnu_pbds::range_invalidation_guarantee
 C__gnu_pbds::cc_hash_max_collision_check_resize_trigger< External_Load_Access, Size_Type >A resize trigger policy based on collision checks. It keeps the simulated load factor lower than some given load factor
 C__gnu_pbds::container_tagBase data structure tag
 C__gnu_pbds::associative_tagBasic associative-container
 C__gnu_pbds::basic_branch_tagBasic branch structure
 C__gnu_pbds::tree_tagBasic tree structure
 C__gnu_pbds::ov_tree_tagOrdered-vector tree
 C__gnu_pbds::rb_tree_tagRed-black tree
 C__gnu_pbds::splay_tree_tagSplay tree
 C__gnu_pbds::trie_tagBasic trie structure
 C__gnu_pbds::pat_trie_tagPATRICIA trie
 C__gnu_pbds::basic_hash_tagBasic hash structure
 C__gnu_pbds::cc_hash_tagCollision-chaining hash
 C__gnu_pbds::gp_hash_tagGeneral-probing hash
 C__gnu_pbds::list_update_tagList-update
 C__gnu_pbds::priority_queue_tagBasic priority-queue
 C__gnu_pbds::binary_heap_tagBinary-heap (array-based)
 C__gnu_pbds::binomial_heap_tagBinomial-heap
 C__gnu_pbds::pairing_heap_tagPairing-heap
 C__gnu_pbds::rc_binomial_heap_tagRedundant-counter binomial-heap
 C__gnu_pbds::thin_heap_tagThin heap
 C__gnu_pbds::sequence_tagBasic sequence
 C__gnu_pbds::string_tagBasic string container, inclusive of strings, ropes, etc
 C__gnu_pbds::container_traits_base< _Tag >Primary template, container traits base
 C__gnu_pbds::container_traits_base< binary_heap_tag >Specialization, binary heap
 C__gnu_pbds::container_traits_base< binomial_heap_tag >Specialization, binomial heap
 C__gnu_pbds::container_traits_base< cc_hash_tag >Specialization, cc hash
 C__gnu_pbds::container_traits_base< gp_hash_tag >Specialization, gp hash
 C__gnu_pbds::container_traits_base< list_update_tag >Specialization, list update
 C__gnu_pbds::container_traits_base< ov_tree_tag >Specialization, ov tree
 C__gnu_pbds::container_traits_base< pairing_heap_tag >Specialization, pairing heap
 C__gnu_pbds::container_traits_base< pat_trie_tag >Specialization, pat trie
 C__gnu_pbds::container_traits_base< rb_tree_tag >Specialization, rb tree
 C__gnu_pbds::container_traits_base< rc_binomial_heap_tag >Specialization, rc binomial heap
 C__gnu_pbds::container_traits_base< splay_tree_tag >Specialization, splay tree
 C__gnu_pbds::container_traits_base< thin_heap_tag >Specialization, thin heap
 C__gnu_pbds::detail::bin_search_tree_const_it_< Node_Pointer, Value_Type, Pointer, Const_Pointer, Reference, Const_Reference, Is_Forward_Iterator, _Alloc >Const iterator
 C__gnu_pbds::detail::bin_search_tree_it_< Node_Pointer, Value_Type, Pointer, Const_Pointer, Reference, Const_Reference, Is_Forward_Iterator, _Alloc >Iterator
 C__gnu_pbds::detail::bin_search_tree_const_node_it_< Node, Const_Iterator, Iterator, _Alloc >Const node iterator
 C__gnu_pbds::detail::bin_search_tree_node_it_< Node, Const_Iterator, Iterator, _Alloc >Node iterator
 C__gnu_pbds::detail::bin_search_tree_traits< Key, Mapped, Cmp_Fn, Node_Update, Node, _Alloc >Binary search tree traits, primary template
 C__gnu_pbds::detail::bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, Node, _Alloc >Specialization
 C__gnu_pbds::detail::binary_heap_point_const_iterator_< Value_Type, Entry, Simple, _Alloc >Const point-type iterator
 C__gnu_pbds::detail::binary_heap_const_iterator_< Value_Type, Entry, Simple, _Alloc >Const point-type iterator
 C__gnu_pbds::detail::branch_policy< Node_CItr, Node_Itr, _Alloc >Primary template, base class for branch structure policies
 C__gnu_pbds::detail::trie_policy_base< Node_CItr, Node_Itr, _ATraits, _Alloc >Base class for trie policies
 C__gnu_pbds::trie_order_statistics_node_update< Node_CItr, Node_Itr, _ATraits, _Alloc >Functor updating ranks of entrees
 C__gnu_pbds::trie_prefix_search_node_update< Node_CItr, Node_Itr, _ATraits, _Alloc >A node updator that allows tries to be searched for the range of values that match a certain prefix
 C__gnu_pbds::tree_order_statistics_node_update< Node_CItr, Node_Itr, Cmp_Fn, _Alloc >Functor updating ranks of entrees
 C__gnu_pbds::detail::branch_policy< Node_CItr, Node_CItr, _Alloc >Specialization for const iterators
 C__gnu_pbds::detail::cond_dealtor< Entry, _Alloc >Conditional deallocate constructor argument
 C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, Tag, Policy_Tl >Dispatch mechanism, primary template for associative types
 C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binary_heap_tag, null_type >Specialization for binary_heap
 C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, binomial_heap_tag, null_type >Specialization for binomial_heap
 C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, pairing_heap_tag, null_type >Specialization for pairing_heap
 C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, rc_binomial_heap_tag, null_type >Specialization for rc_binary_heap
 C__gnu_pbds::detail::container_base_dispatch< _VTp, Cmp_Fn, _Alloc, thin_heap_tag, null_type >Specialization for thin_heap
 C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, cc_hash_tag, Policy_Tl >Specialization colision-chaining hash map
 C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, gp_hash_tag, Policy_Tl >Specialization general-probe hash map
 C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, list_update_tag, Policy_Tl >Specialization for list-update map
 C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, ov_tree_tag, Policy_Tl >Specialization ordered-vector tree map
 C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, pat_trie_tag, Policy_Tl >Specialization for PATRICIA trie map
 C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, rb_tree_tag, Policy_Tl >Specialization for R-B tree map
 C__gnu_pbds::detail::container_base_dispatch< Key, Mapped, _Alloc, splay_tree_tag, Policy_Tl >Specialization splay tree map
 C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, cc_hash_tag, Policy_Tl >Specialization colision-chaining hash set
 C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, gp_hash_tag, Policy_Tl >Specialization general-probe hash set
 C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, list_update_tag, Policy_Tl >Specialization for list-update set
 C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, ov_tree_tag, Policy_Tl >Specialization ordered-vector tree set
 C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, pat_trie_tag, Policy_Tl >Specialization for PATRICIA trie set
 C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, rb_tree_tag, Policy_Tl >Specialization for R-B tree set
 C__gnu_pbds::detail::container_base_dispatch< Key, null_type, _Alloc, splay_tree_tag, Policy_Tl >Specialization splay tree set
 C__gnu_pbds::detail::default_comb_hash_fnPrimary template, default_comb_hash_fn
 C__gnu_pbds::detail::default_eq_fn< Key >Primary template, default_eq_fn
 C__gnu_pbds::detail::default_hash_fn< Key >Primary template, default_hash_fn
 C__gnu_pbds::detail::default_probe_fn< Comb_Probe_Fn >Primary template, default_probe_fn
 C__gnu_pbds::detail::default_resize_policy< Comb_Hash_Fn >Primary template, default_resize_policy
 C__gnu_pbds::detail::default_trie_access_traits< Key >Primary template, default_trie_access_traits
 C__gnu_pbds::detail::default_trie_access_traits< std::basic_string< Char, Char_Traits, std::allocator< char > > >Partial specialization, default_trie_access_traits
 C__gnu_pbds::detail::default_update_policyDefault update policy
 C__gnu_pbds::detail::dumnode_const_iterator< Key, Data, _Alloc >Constant node iterator
 C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, No_Throw >Entry compare, primary template
 C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, false >Specialization, false
 C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, false >::typeCompare plus entry
 C__gnu_pbds::detail::entry_cmp< _VTp, Cmp_Fn, _Alloc, true >Specialization, true
 C__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, No_Throw >Entry predicate primary class template
 C__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, false >Specialization, false
 C__gnu_pbds::detail::entry_pred< _VTp, Pred, _Alloc, true >Specialization, true
 C__gnu_pbds::detail::eq_by_less< Key, Cmp_Fn >Equivalence function
 C__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, Store_Hash >Primary template
 C__gnu_pbds::detail::cc_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Hash_Fn, Resize_Policy >
 C__gnu_pbds::detail::gp_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy >
 C__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, false >Specialization 1 - The client requests that hash values not be stored
 C__gnu_pbds::detail::hash_eq_fn< Key, Eq_Fn, _Alloc, true >Specialization 2 - The client requests that hash values be stored
 C__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< Size_Type, Hold_Size >Primary template
 C__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< Size_Type, true >Specializations
 C__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, Node_Metadata, _Alloc >Base class for a basic heap
 C__gnu_pbds::detail::left_child_next_sibling_heap_node_< _Value, _Metadata, _Alloc >Node
 C__gnu_pbds::detail::left_child_next_sibling_heap_node_point_const_iterator_< Node, _Alloc >Const point-type iterator
 C__gnu_pbds::detail::left_child_next_sibling_heap_const_iterator_< Node, _Alloc >Const point-type iterator
 C__gnu_pbds::detail::lu_counter_metadata< Size_Type >A list-update metadata type that moves elements to the front of the list based on the counter algorithm
 C__gnu_pbds::detail::lu_counter_policy_base< Size_Type >Base class for list-update counter policy
 C__gnu_pbds::detail::mask_based_range_hashing< Size_Type >Range hashing policy
 C__gnu_pbds::direct_mask_range_hashing< Size_Type >A mask range-hashing class (uses a bitmask)
 C__gnu_pbds::detail::mod_based_range_hashing< Size_Type >Mod based range hashing
 C__gnu_pbds::direct_mod_range_hashing< Size_Type >A mod range-hashing class (uses the modulo function)
 C__gnu_pbds::detail::no_throw_copies< Key, Mapped >Primary template
 C__gnu_pbds::detail::no_throw_copies< Key, null_type >Specialization
 C__gnu_pbds::detail::ov_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc >::cond_dtor< Size_Type >Conditional destructor
 C__gnu_pbds::detail::ov_tree_node_const_it_< Value_Type, Metadata_Type, _Alloc >Const node reference
 C__gnu_pbds::detail::ov_tree_node_it_< Value_Type, Metadata_Type, _Alloc >Node reference
 C__gnu_pbds::detail::pat_trie_baseBase type for PATRICIA trees
 C__gnu_pbds::detail::pat_trie_map< Key, Mapped, Node_And_It_Traits, _Alloc >PATRICIA trie.This implementation loosely borrows ideas from: 1) Fast Mergeable Integer Maps, Okasaki, Gill 1998 2) Ptset: Sets of integers implemented as Patricia trees, Jean-Christophe Filliatr, 2000
 C__gnu_pbds::detail::pat_trie_base::_CIter< Node, Leaf, Head, Inode, Is_Forward_Iterator >Const iterator
 C__gnu_pbds::detail::pat_trie_base::_Iter< Node, Leaf, Head, Inode, Is_Forward_Iterator >Iterator
 C__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata >::const_iteratorConstant child iterator
 C__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata >::iteratorChild iterator
 C__gnu_pbds::detail::pat_trie_base::_Metadata< Metadata, _Alloc >Metadata base primary template
 C__gnu_pbds::detail::pat_trie_base::_Metadata< null_type, _Alloc >Specialization for null metadata
 C__gnu_pbds::detail::pat_trie_base::_Node_base< _ATraits, Metadata >Node base
 C__gnu_pbds::detail::pat_trie_base::_Head< _ATraits, Metadata >Head node for PATRICIA tree
 C__gnu_pbds::detail::pat_trie_base::_Inode< _ATraits, Metadata >Internal node type, PATRICIA tree
 C__gnu_pbds::detail::pat_trie_base::_Leaf< _ATraits, Metadata >Leaf node for PATRICIA tree
 C__gnu_pbds::detail::pat_trie_base::_Node_citer< Node, Leaf, Head, Inode, _CIterator, Iterator, _Alloc >Node const iterator
 C__gnu_pbds::detail::pat_trie_base::_Node_iter< Node, Leaf, Head, Inode, _CIterator, Iterator, _Alloc >Node iterator
 C__gnu_pbds::detail::probe_fn_base< _Alloc >Probe functor base
 C__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, Store_Hash >Primary template
 C__gnu_pbds::detail::cc_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Hash_Fn, Resize_Policy >
 C__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, false >
 C__gnu_pbds::detail::ranged_hash_fn< Key, Hash_Fn, _Alloc, Comb_Hash_Fn, true >
 C__gnu_pbds::detail::ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, false >
 C__gnu_pbds::detail::ranged_hash_fn< Key, null_type, _Alloc, Comb_Hash_Fn, true >
 C__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, Store_Hash >Primary template
 C__gnu_pbds::detail::gp_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy >
 C__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, false >
 C__gnu_pbds::detail::ranged_probe_fn< Key, Hash_Fn, _Alloc, Comb_Probe_Fn, Probe_Fn, true >
 C__gnu_pbds::detail::ranged_probe_fn< Key, null_type, _Alloc, Comb_Probe_Fn, null_type, false >
 C__gnu_pbds::detail::rb_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc >Red-Black tree.This implementation uses an idea from the SGI STL (using a header node which is needed for efficient iteration)
 C__gnu_pbds::detail::rb_tree_node_< Value_Type, Metadata, _Alloc >Node for Red-Black trees
 C__gnu_pbds::detail::rc< _Node, _Alloc >Redundant binary counter
 C__gnu_pbds::detail::resize_policy< _Tp >Resize policy for binary heap
 C__gnu_pbds::detail::splay_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc >Splay tree
 C__gnu_pbds::detail::splay_tree_node_< Value_Type, Metadata, _Alloc >Node for splay tree
 C__gnu_pbds::detail::stored_hash< _Th >Stored hash
 C__gnu_pbds::detail::stored_data< _Tv, _Th >Primary template for representation of stored data. Two types of data can be stored: value and hash
 C__gnu_pbds::detail::stored_value< _Tv >Stored value
 C__gnu_pbds::detail::stored_data< _Tv, _Th >Primary template for representation of stored data. Two types of data can be stored: value and hash
 C__gnu_pbds::detail::stored_data< _Tv, null_type >Specialization for representation of stored data of just value type
 C__gnu_pbds::detail::synth_access_traits< Type_Traits, Set, _ATraits >Synthetic element access traits
 C__gnu_pbds::detail::tree_metadata_helper< Node_Update, _BTp >Tree metadata helper
 C__gnu_pbds::detail::tree_metadata_helper< Node_Update, false >Specialization, false
 C__gnu_pbds::detail::tree_metadata_helper< Node_Update, true >Specialization, true
 C__gnu_pbds::detail::tree_node_metadata_dispatch< Key, Data, Cmp_Fn, Node_Update, _Alloc >Tree node metadata dispatch
 C__gnu_pbds::detail::tree_traits< Key, Data, Cmp_Fn, Node_Update, Tag, _Alloc >Tree traits class, primary template
 C__gnu_pbds::detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc >Tree traits
 C__gnu_pbds::detail::tree_traits< Key, null_type, Cmp_Fn, Node_Update, ov_tree_tag, _Alloc >Specialization
 C__gnu_pbds::detail::trie_metadata_helper< Node_Update, _BTp >Trie metadata helper
 C__gnu_pbds::detail::trie_metadata_helper< Node_Update, false >Specialization, false
 C__gnu_pbds::detail::trie_metadata_helper< Node_Update, true >Specialization, true
 C__gnu_pbds::detail::trie_node_metadata_dispatch< Key, Data, Cmp_Fn, Node_Update, _Alloc >Trie node metadata dispatch
 C__gnu_pbds::detail::trie_traits< Key, Data, _ATraits, Node_Update, Tag, _Alloc >Trie traits class, primary template
 C__gnu_pbds::detail::trie_traits< Key, Mapped, _ATraits, Node_Update, pat_trie_tag, _Alloc >Specialization
 C__gnu_pbds::detail::trie_traits< Key, null_type, _ATraits, Node_Update, pat_trie_tag, _Alloc >Specialization
 C__gnu_pbds::detail::type_base< Key, Mapped, _Alloc, Store_Hash >Primary template
 C__gnu_pbds::detail::types_traits< Key, Mapped, _Alloc, Store_Hash >Traits for abstract types
 C__gnu_pbds::detail::cc_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Hash_Fn, Resize_Policy >
 C__gnu_pbds::detail::gp_ht_map< Key, Mapped, Hash_Fn, Eq_Fn, _Alloc, Store_Hash, Comb_Probe_Fn, Probe_Fn, Resize_Policy >
 C__gnu_pbds::detail::types_traits< Key, Mapped, _Alloc, false >
 C__gnu_pbds::detail::lu_map< Key, Mapped, Eq_Fn, _Alloc, Update_Policy >List-based (with updates) associative container. Skip to the lu, my darling
 C__gnu_pbds::detail::ov_tree_map< Key, Mapped, Cmp_Fn, Node_And_It_Traits, _Alloc >Ordered-vector tree associative-container
 C__gnu_pbds::detail::pat_trie_map< Key, Mapped, Node_And_It_Traits, _Alloc >PATRICIA trie.This implementation loosely borrows ideas from: 1) Fast Mergeable Integer Maps, Okasaki, Gill 1998 2) Ptset: Sets of integers implemented as Patricia trees, Jean-Christophe Filliatr, 2000
 C__gnu_pbds::detail::type_base< Key, Mapped, _Alloc, false >
 C__gnu_pbds::detail::type_base< Key, Mapped, _Alloc, true >
 C__gnu_pbds::detail::type_base< Key, null_type, _Alloc, false >
 C__gnu_pbds::detail::type_base< Key, null_type, _Alloc, true >
 C__gnu_pbds::detail::type_dispatch< Key, Mapped, _Alloc, Store_Hash >Type base dispatch
 C__gnu_pbds::hash_exponential_size_policy< Size_Type >A size policy whose sequence of sizes form an exponential sequence (typically powers of 2
 C__gnu_pbds::hash_prime_size_policyA size policy whose sequence of sizes form a nearly-exponential sequence of primes
 C__gnu_pbds::hash_standard_resize_policy< Size_Policy, Trigger_Policy, External_Size_Access, Size_Type >A resize policy which delegates operations to size and trigger policies
 C__gnu_pbds::linear_probe_fn< Size_Type >A probe sequence policy using fixed increments
 C__gnu_pbds::list_update< Key, Mapped, Eq_Fn, Update_Policy, _Alloc >
 C__gnu_pbds::lu_move_to_front_policy< _Alloc >
 C__gnu_pbds::null_typeRepresents no type, or absence of type, for template tricks
 C__gnu_pbds::null_node_update< _Tp1, _Tp2, _Tp3, _Tp4 >A null node updator, indicating that no node updates are required
 C__gnu_pbds::priority_queue< _Tv, Cmp_Fn, Tag, _Alloc >
 C__gnu_pbds::quadratic_probe_fn< Size_Type >A probe sequence policy using square increments
 C__gnu_pbds::sample_probe_fnA sample probe policy
 C__gnu_pbds::sample_range_hashingA sample range-hashing functor
 C__gnu_pbds::sample_ranged_hash_fnA sample ranged-hash functor
 C__gnu_pbds::sample_ranged_probe_fnA sample ranged-probe functor
 C__gnu_pbds::sample_resize_policyA sample resize policy
 C__gnu_pbds::sample_resize_triggerA sample resize trigger policy
 C__gnu_pbds::sample_size_policyA sample size policy
 C__gnu_pbds::sample_tree_node_update< Const_Node_Iter, Node_Iter, Cmp_Fn, _Alloc >A sample node updator
 C__gnu_pbds::sample_trie_access_traitsA sample trie element access traits
 C__gnu_pbds::sample_trie_node_update< Node_CItr, Node_Itr, _ATraits, _Alloc >A sample node updator
 C__gnu_pbds::sample_update_policyA sample list-update policy
 C__gnu_pbds::trie_string_access_traits< String, Min_E_Val, Max_E_Val, Reverse, _Alloc >
 C__gnu_pbds::trivial_iterator_tagA trivial iterator tag. Signifies that the iterators has none of std::iterators's movement abilities
 C__gnu_profile::__object_info_baseBase class for a line in the object table
 C__gnu_profile::__container_size_infoA container size instrumentation line in the object table
 C__gnu_profile::__container_size_stack_infoA container size instrumentation line in the stack table
 C__gnu_profile::__hashfunc_infoA hash performance instrumentation line in the object table
 C__gnu_profile::__hashfunc_stack_infoA hash performance instrumentation line in the stack table
 C__gnu_profile::__list2vector_infoA list-to-vector instrumentation line in the object table
 C__gnu_profile::__map2umap_infoA map-to-unordered_map instrumentation line in the object table
 C__gnu_profile::__map2umap_stack_infoA map-to-unordered_map instrumentation line in the stack table
 C__gnu_profile::__vector2list_infoA vector-to-list instrumentation line in the object table
 C__gnu_profile::__vector2list_stack_infoA vector-to-list instrumentation line in the stack table
 C__gnu_profile::__reentrance_guardReentrance guard
 C__gnu_profile::__stack_hashHash function for summary trace using call stack as index
 C__gnu_profile::__trace_base< __object_info, __stack_info >Base class for all trace producers
 C__gnu_profile::__warning_dataRepresentation of a warning
 Cstd::__is_trivially_copy_assignable_impl< _Tp >
 Cstd::__is_trivially_copy_constructible_impl< _Tp >
 Cstd::__is_trivially_move_assignable_impl< _Tp >
 Cstd::__is_trivially_move_constructible_impl< _Tp >
 Cstd::__iterator_traits< _Iterator >
 Cstd::__iterator_traits< _Tp >
 C__gnu_profile::__trace_base< __container_size_info, __container_size_stack_info >
 C__gnu_profile::__trace_container_sizeContainer size instrumentation trace producer
 C__gnu_profile::__trace_hashtable_sizeHashtable size instrumentation trace producer
 C__gnu_profile::__trace_vector_sizeHashtable size instrumentation trace producer
 C__gnu_profile::__trace_base< __hashfunc_info, __hashfunc_stack_info >
 C__gnu_profile::__trace_hash_funcHash performance instrumentation producer
 C__gnu_profile::__trace_base< __list2slist_info, __list2slist_stack_info >
 C__gnu_profile::__trace_base< __list2vector_info, __list2vector_stack_info >
 C__gnu_profile::__trace_base< __map2umap_info, __map2umap_stack_info >
 C__gnu_profile::__trace_map2umapMap-to-unordered_map instrumentation producer
 C__gnu_profile::__trace_base< __vector2list_info, __vector2list_stack_info >
 C__gnu_profile::__trace_vector_to_listVector-to-list instrumentation producer
 Cstd::_Base_bitset<((_Nb)/(__CHAR_BIT__ *__SIZEOF_LONG__)+((_Nb) %(__CHAR_BIT__ *__SIZEOF_LONG__)==0 ? 0 :1))>
 Cstd::bitset< _Nb >The bitset class represents a fixed-size sequence of bits.(Note that bitset does not meet the formal requirements of a container. Mainly, it lacks iterators.)
 C__gnu_cxx::__detail::_Bitmap_counter< _Alloc_block * >
 Cstd::_Deque_base< _StateSeqT, std::allocator< _StateSeqT > >
 Cstd::deque< _StateSeqT >
 Cstd::_Deque_iterator< _Tp, _Tp &, _Ptr >
 Cstd::_Enable_copy_move< is_copy_constructible< _Tp >::value, __and_< is_copy_constructible< _Tp >, is_copy_assignable< _Tp > >::value, is_move_constructible< _Tp >::value, __and_< is_move_constructible< _Tp >, is_move_assignable< _Tp > >::value, optional< _Tp > >
 Cstd::experimental::fundamentals_v1::optional< _Tp >Class template for optional values
 Cstd::_Enable_default_constructor< _Default, _Tag >
 Cstd::_Enable_special_members< _Default, _Destructor, _Copy, _CopyAssignment, _Move, _MoveAssignment, _Tag >A mixin helper to conditionally enable or disable the special members
 Cstd::_Enable_destructor< _Destructor, _Tag >
 Cstd::_Enable_special_members< _Default, _Destructor, _Copy, _CopyAssignment, _Move, _MoveAssignment, _Tag >A mixin helper to conditionally enable or disable the special members
 Cstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, _Traits::__hash_cached::value >
 Cstd::__detail::_Hashtable_base< _Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, _Traits >
 Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
 Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
 Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 Cstd::__detail::_Hashtable_ebo_helper< 0, __alloc_rebind< _Alloc, __detail::_Hash_node< _Value, _Traits::__hash_cached::value > > >
 Cstd::__detail::_Hashtable_alloc< __alloc_rebind< _Alloc, __detail::_Hash_node< _Value, _Traits::__hash_cached::value > > >
 Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 Cstd::__detail::_Hashtable_ebo_helper< 0, _Equal >
 Cstd::__detail::_Hashtable_base< _Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, _Traits >
 Cstd::__detail::_Hashtable_ebo_helper< 0, _ExtractKey >
 Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, false >Specialization: hash function and range-hashing function, no caching of hash codes. Provides typedef and accessor required by C++ 11
 Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, true >Specialization: hash function and range-hashing function, caching hash codes. H is provided but ignored. Provides typedef and accessor required by C++ 11
 Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, false >Specialization: ranged hash function, no caching hash codes. H1 and H2 are provided but ignored. We define a dummy hash code type
 Cstd::__detail::_Hashtable_ebo_helper< 0, _H2 >
 Cstd::__detail::_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, true >Partial specialization used when nodes contain a cached hash code
 Cstd::__detail::_Hashtable_ebo_helper< 0, _NodeAlloc >
 Cstd::__detail::_Hashtable_alloc< _NodeAlloc >
 Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
 Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
 Cstd::__detail::_Hashtable_ebo_helper< 1, _H1 >
 Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, false >Specialization: hash function and range-hashing function, no caching of hash codes. Provides typedef and accessor required by C++ 11
 Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, true >Specialization: hash function and range-hashing function, caching hash codes. H is provided but ignored. Provides typedef and accessor required by C++ 11
 Cstd::__detail::_Hashtable_ebo_helper< 1, _Hash >
 Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, false >Specialization: ranged hash function, no caching hash codes. H1 and H2 are provided but ignored. We define a dummy hash code type
 Cstd::__detail::_Hashtable_ebo_helper< 2, _H2 >
 Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, false >Specialization: hash function and range-hashing function, no caching of hash codes. Provides typedef and accessor required by C++ 11
 Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, true >Specialization: hash function and range-hashing function, caching hash codes. H is provided but ignored. Provides typedef and accessor required by C++ 11
 Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 Cstd::_List_base< __inp, __rebind_inp >
 Cstd::list< __inp, __rebind_inp >
 Cstd::__detail::_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache >
 Cstd::__detail::_Local_const_iterator< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __constant_iterators, __cache >Local const_iterators
 Cstd::__detail::_Local_iterator< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __constant_iterators, __cache >Local iterators
 Cstd::__detail::_Map_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 Cstd::_Maybe_get_result_type< _Functor >
 Cstd::_Weak_result_type_impl< _Functor >
 Cstd::_Maybe_get_result_type< remove_cv< _Functor >::type >
 Cstd::_Weak_result_type_impl< remove_cv< _Functor >::type >
 Cstd::_Maybe_get_result_type< remove_cv< _Tp >::type >
 Cstd::_Weak_result_type_impl< remove_cv< _Tp >::type >
 Cstd::_Maybe_get_result_type< remove_cv< remove_cv< _Tp >::type >::type >
 Cstd::_Weak_result_type_impl< remove_cv< remove_cv< _Tp >::type >::type >
 Cstd::_Maybe_unary_or_binary_function< _Res, _ArgTypes... >
 Cstd::function< _Res(_ArgTypes...)>Primary class template for std::function.Polymorphic function wrapper
 Cstd::__detail::_Node_iterator_base< _Value, __cache >
 Cstd::__detail::_Node_const_iterator< _Value, __constant_iterators, __cache >Node const_iterators, used to iterate through all the hashtable
 Cstd::__detail::_Node_iterator< _Value, __constant_iterators, __cache >Node iterators, used to iterate through all the hashtable
 Cstd::experimental::fundamentals_v1::_Optional_base< _Tp >
 Cstd::experimental::fundamentals_v1::optional< _Tp >Class template for optional values
 Cstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 Cstd::_Hashtable< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 C__gnu_parallel::_RestrictedBoundedConcurrentQueue< pair< _RAIter, _RAIter > >
 C__gnu_debug::_Safe_vector< vector< _Tp, _Allocator >, ::vector< _Tp, _Allocator > >
 Cstd::__debug::vector< _Tp, _Allocator >Class std::vector with safety/checking/debug instrumentation
 Cstd::_Tuple_impl< 0, _Elements... >
 Cstd::tuple< _Elements >Primary class template, tuple
 Cstd::tuple< _Bound_args... >
 Cstd::tuple< _ForwardIterator1, _ForwardIterator1, _BinaryPredicate >
 Cstd::tuple< pointer, _Dp >
 Cstd::tuple< pointer, default_delete< _Codecvt > >
 Cstd::tuple< pointer, default_delete< _Res_type > >
 Cstd::tuple< pointer, default_delete< _Result< _Res > > >
 Cstd::tuple< pointer, default_delete< _Result_base > >
 Cstd::tuple< pointer, default_delete< bool > >
 Cstd::tuple< std::array< _Tp, _Len >, _Pred >
 Cstd::_Tuple_impl< 0, _T1, _T2 >
 Cstd::tuple< _T1, _T2 >Partial specialization, 2-element tuple. Includes construction and assignment from a pair
 Cstd::_Tuple_impl< _Idx+1, _Tail... >
 Cstd::_Tuple_impl< _Idx, _Head, _Tail... >
 Cstd::_Vector_base< __diff_type, std::allocator< __diff_type > >
 Cstd::vector< __diff_type >
 Cstd::_Vector_base< __gnu_parallel::_Piece< _DifferenceType >, std::allocator< __gnu_parallel::_Piece< _DifferenceType > > >
 Cstd::vector< __gnu_parallel::_Piece< _DifferenceType > >
 Cstd::_Vector_base< _CharClassT, std::allocator< _CharClassT > >
 Cstd::vector< _CharClassT >
 Cstd::_Vector_base< _CharT, std::allocator< _CharT > >
 Cstd::vector< _CharT >
 Cstd::_Vector_base< _Cmpt, std::allocator< _Cmpt > >
 Cstd::vector< _Cmpt >
 Cstd::_Vector_base< _Node *, _Nodeptr_Alloc >
 Cstd::vector< _Node *, _Nodeptr_Alloc >
 Cstd::_Vector_base< _RealType, std::allocator< _RealType > >
 Cstd::vector< _RealType >
 Cstd::_Vector_base< _State< _TraitsT::char_type >, std::allocator< _State< _TraitsT::char_type > > >
 Cstd::vector< _State< _TraitsT::char_type > >
 Cstd::_Vector_base< _StringT, std::allocator< _StringT > >
 Cstd::vector< _StringT >
 Cstd::_Vector_base< block_type, allocator_type >
 Cstd::vector< block_type, allocator_type >
 Cstd::_Vector_base< Catalog_info *, std::allocator< Catalog_info * > >
 Cstd::vector< Catalog_info * >
 Cstd::_Vector_base< double, std::allocator< double > >
 Cstd::vector< double >
 Cstd::_Vector_base< int, std::allocator< int > >
 Cstd::vector< int >
 Cstd::_Vector_base< result_type, std::allocator< result_type > >
 Cstd::vector< result_type >
 Cstd::_Vector_base< size_t, std::allocator< size_t > >
 Cstd::vector< size_t >
 Cstd::_Vector_base< std::pair< _BiIter, int >, std::allocator< std::pair< _BiIter, int > > >
 Cstd::vector< std::pair< _BiIter, int > >
 Cstd::_Vector_base< std::pair< _StateIdT, std::vector >, std::allocator< std::pair< _StateIdT, std::vector > > >
 Cstd::vector< std::pair< _StateIdT, std::vector > >
 Cstd::_Vector_base< std::pair< _StrTransT, _StrTransT >, std::allocator< std::pair< _StrTransT, _StrTransT > > >
 Cstd::vector< std::pair< _StrTransT, _StrTransT > >
 Cstd::_Vector_base< sub_match< _Bi_iter >, _Alloc >
 Cstd::vector< sub_match< _Bi_iter >, _Alloc >
 Cstd::match_results< _Bi_iter, _Alloc >The results of a match or search operation
 Cstd::_Vector_base< sub_match< _Bi_iter >, allocator< sub_match< _Bi_iter > > >
 Cstd::vector< sub_match< _Bi_iter >, allocator< sub_match< _Bi_iter > > >
 Cstd::match_results< _Bi_iter >
 Cstd::_Vector_base< sub_match< _BiIter >, _Alloc >
 Cstd::vector< sub_match< _BiIter >, _Alloc >
 Cstd::_Weak_result_type< _Tp >
 Cstd::_Reference_wrapper_base< _Tp >
 Cstd::_Weak_result_type< remove_cv< _Tp >::type >
 Cstd::_Reference_wrapper_base< remove_cv< _Tp >::type >
 Cstd::aligned_storage< sizeof(_M_ptr), alignof(void *)>
 Cstd::aligned_storage< sizeof(_Res), __alignof__(_Res)>
 Cstd::aligned_storage< sizeof(_Tp), __alignof__(_Tp)>
 Cstd::aligned_storage< sizeof(_Tp), alignof(_Tp)>
 Cstd::aligned_storage< sizeof(_Value), __alignof__(_Value)>
 Cstd::allocator_traits< _Tp_alloc_type >
 C__gnu_cxx::__alloc_traits< _Tp_alloc_type >
 C__gnu_pbds::basic_branch< Key, Mapped, Tag, detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, Tag, _Alloc > ::node_update, __gnu_cxx::typelist::create2< Cmp_Fn, detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, Tag, _Alloc > >::type, _Alloc >
 C__gnu_pbds::tree< Key, Mapped, Cmp_Fn, Tag, Node_Update, _Alloc >
 C__gnu_pbds::basic_branch< Key, Mapped, Tag, detail::trie_traits< Key, Mapped, _ATraits, Node_Update, Tag, _Alloc > ::node_update, __gnu_cxx::typelist::create2< _ATraits, detail::trie_traits< Key, Mapped, _ATraits, Node_Update, Tag, _Alloc > >::type, _Alloc >
 C__gnu_pbds::trie< Key, Mapped, _ATraits, Tag, Node_Update, _Alloc >
 C__gnu_pbds::basic_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, cc_hash_tag, __gnu_cxx::typelist::create1< Comb_Hash_Fn >::type, _Alloc >
 C__gnu_pbds::cc_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Comb_Hash_Fn, Resize_Policy, Store_Hash, _Alloc >
 C__gnu_pbds::basic_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Resize_Policy, Store_Hash, gp_hash_tag, __gnu_cxx::typelist::create2< Comb_Probe_Fn, Probe_Fn >::type, _Alloc >
 C__gnu_pbds::gp_hash_table< Key, Mapped, Hash_Fn, Eq_Fn, Comb_Probe_Fn, Probe_Fn, Resize_Policy, Store_Hash, _Alloc >
 Cstd::basic_streambuf< _Elem, _Tr >
 Cstd::wbuffer_convert< _Codecvt, _Elem, _Tr >Buffer conversions
 Cstd::basic_streambuf< char, _Traits >
 Cstd::basic_streambuf< char, char_traits< char > >
 Cstd::basic_string< _CharT >
 Cstd::basic_string< _CharT, _Traits, _Allocator >
 C__gnu_debug::basic_string< _CharT, _Traits, _Allocator >Class std::basic_string with safety/checking/debug instrumentation
 Cstd::basic_string< _Elem, char_traits< _Elem >, _Wide_alloc >
 Cstd::basic_string< char >
 Cstd::basic_string< char, char_traits< char >, _Byte_alloc >
 Cstd::basic_string< char_type, _Traits, _Alloc >
 Cstd::basic_string< value_type >
 C__gnu_pbds::detail::bin_search_tree_traits< Key, Mapped, Cmp_Fn, Node_Update, rb_tree_node_< types_traits< Key, Mapped, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, Mapped, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc >
 C__gnu_pbds::detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc >Specialization
 C__gnu_pbds::detail::bin_search_tree_traits< Key, Mapped, Cmp_Fn, Node_Update, splay_tree_node_< types_traits< Key, Mapped, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, Mapped, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc >
 C__gnu_pbds::detail::tree_traits< Key, Mapped, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc >Specialization
 C__gnu_pbds::detail::bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, rb_tree_node_< types_traits< Key, null_type, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, null_type, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc >
 C__gnu_pbds::detail::tree_traits< Key, null_type, Cmp_Fn, Node_Update, rb_tree_tag, _Alloc >Specialization
 C__gnu_pbds::detail::bin_search_tree_traits< Key, null_type, Cmp_Fn, Node_Update, splay_tree_node_< types_traits< Key, null_type, _Alloc, false >::value_type, tree_node_metadata_dispatch< Key, null_type, Cmp_Fn, Node_Update, _Alloc >::type, _Alloc >, _Alloc >
 C__gnu_pbds::detail::tree_traits< Key, null_type, Cmp_Fn, Node_Update, splay_tree_tag, _Alloc >Specialization
 Cstd::binary_function< __shared_ptr< _Tp, _Lp >, __shared_ptr< _Tp, _Lp >, bool >
 Cstd::binary_function< __weak_ptr< _Tp, _Lp >, __weak_ptr< _Tp, _Lp >, bool >
 Cstd::binary_function< _Arg1, _Arg2, _Arg1 >
 Cstd::binary_function< _Arg1, _Arg2, _Arg2 >
 Cstd::binary_function< _Predicate::first_argument_type, _Predicate::second_argument_type, bool >
 Cstd::binary_negate< _Predicate >One of the negation functors
 Cstd::binary_function< _Sp, _Sp, bool >
 Cstd::binary_function< _T1, _T2, _Res >
 Cstd::_Maybe_unary_or_binary_function< _Res, _T1, _T2 >Derives from binary_function, as appropriate
 Cstd::binary_function< _T1, _T2, bool >
 C__gnu_parallel::_EqualFromLess< _T1, _T2, _Compare >Constructs predicate for equality from strict weak ordering predicate
 C__gnu_parallel::_EqualTo< _T1, _T2 >Similar to std::equal_to, but allows two different types
 C__gnu_parallel::_Less< _T1, _T2 >Similar to std::less, but allows two different types
 C__gnu_parallel::_LexicographicReverse< _T1, _T2, _Compare >Compare __a pair of types lexicographically, descending
 Cstd::binary_function< _Tp *, _Arg, _Ret >
 Cstd::mem_fun1_t< _Ret, _Tp, _Arg >One of the adaptors for member pointers
 Cstd::binary_function< _Tp *, _Tp *, bool >
 Cstd::binary_function< _Tp, _Arg, _Ret >
 Cstd::const_mem_fun1_ref_t< _Ret, _Tp, _Arg >One of the adaptors for member pointers
 Cstd::mem_fun1_ref_t< _Ret, _Tp, _Arg >One of the adaptors for member pointers
 Cstd::binary_function< _Tp, _Tp, _Tp >
 Cstd::divides< _Tp >One of the math functors
 Cstd::minus< _Tp >One of the math functors
 Cstd::modulus< _Tp >One of the math functors
 Cstd::multiplies< _Tp >One of the math functors
 Cstd::plus< _Tp >One of the math functors
 Cstd::binary_function< _Tp, _Tp, bool >
 Cstd::equal_to< _Tp >One of the comparison functors
 Cstd::greater< _Tp >One of the comparison functors
 Cstd::greater_equal< _Tp >One of the comparison functors
 Cstd::less< _Tp >One of the comparison functors
 Cstd::less_equal< _Tp >One of the comparison functors
 Cstd::logical_and< _Tp >One of the Boolean operations functors
 Cstd::logical_or< _Tp >One of the Boolean operations functors
 Cstd::not_equal_to< _Tp >One of the comparison functors
 Cstd::binary_function< _Tp1, _Tp2, _Result >
 C__gnu_parallel::_Multiplies< _Tp1, _Tp2, _Result >Similar to std::multiplies, but allows two different types
 C__gnu_parallel::_Plus< _Tp1, _Tp2, _Result >Similar to std::plus, but allows two different types
 Cstd::binary_function< const _Tp *, _Arg, _Ret >
 Cstd::const_mem_fun1_t< _Ret, _Tp, _Arg >One of the adaptors for member pointers
 Cstd::binary_function< rope< _CharT, _Alloc >, rope< _CharT, _Alloc >, rope< _CharT, _Alloc > >
 Cstd::binary_function< shared_ptr< _Tp >, shared_ptr< _Tp >, bool >
 Cstd::binary_function< std::pair< _T1, _T2 >, std::pair< _T1, _T2 >, bool >
 C__gnu_parallel::_Lexicographic< _T1, _T2, _Compare >Compare __a pair of types lexicographically, ascending
 Cstd::binary_function< value_type, value_type, bool >
 Cstd::binary_function< void, void, bool >
 Cstd::binary_function< weak_ptr< _Tp >, weak_ptr< _Tp >, bool >
 Cstd::common_type< _Tp, _Tp >
 Cstd::common_type< _Types... >
 Cstd::conditional< _UseCache::value, std::bitset< _S_cache_size()>, _Dummy >
 C__gnu_pbds::container_traits_base< Cntnr::container_category >
 C__gnu_pbds::container_traits< Cntnr >Container traits
 Cstd::gamma_distribution< double >
 Cstd::gamma_distribution< result_type >
 C__gnu_pbds::detail::hash_load_check_resize_trigger_size_base< Size_Type, External_Load_Access >
 C__gnu_pbds::hash_load_check_resize_trigger< External_Load_Access, Size_Type >A resize trigger policy based on a load check. It keeps the load factor between some load factors load_min and load_max
 Cstd::integral_constant< _Rep, static_cast< _Rep >(_Val)>
 Cstd::integral_constant< bool, !is_function< _Tp >::value >
 Cstd::integral_constant< bool, !is_fundamental< _Tp >::value >
 Cstd::is_compound< _Tp >Is_compound
 Cstd::integral_constant< bool, !ratio_equal< _R1, _R2 >::value >
 Cstd::ratio_not_equal< _R1, _R2 >Ratio_not_equal
 Cstd::integral_constant< bool, __big_less< _Left::__hi, _Left::__lo, _Right::__hi, _Right::__lo >::value >
 Cstd::integral_constant< bool, __has_virtual_destructor(_Tp)>
 Cstd::has_virtual_destructor< _Tp >Has_virtual_destructor
 Cstd::integral_constant< bool, __is_abstract(_Tp)>
 Cstd::is_abstract< _Tp >Is_abstract
 Cstd::integral_constant< bool, __is_base_of(_Base, _Derived)>
 Cstd::is_base_of< _Base, _Derived >Is_base_of
 Cstd::integral_constant< bool, __is_class(_Tp)>
 Cstd::is_class< _Tp >Is_class
 Cstd::integral_constant< bool, __is_empty(_Tp)>
 Cstd::is_empty< _Tp >Is_empty
 Cstd::integral_constant< bool, __is_enum(_Tp)>
 Cstd::is_enum< _Tp >Is_enum
 Cstd::integral_constant< bool, __is_final(_Tp)>
 Cstd::is_final< _Tp >Is_final
 Cstd::integral_constant< bool, __is_literal_type(_Tp)>
 Cstd::is_literal_type< _Tp >Is_literal_type
 Cstd::integral_constant< bool, __is_pod(_Tp)>
 Cstd::is_pod< _Tp >Is_pod
 Cstd::integral_constant< bool, __is_polymorphic(_Tp)>
 Cstd::is_polymorphic< _Tp >Is_polymorphic
 Cstd::integral_constant< bool, __is_standard_layout(_Tp)>
 Cstd::is_standard_layout< _Tp >Is_standard_layout
 Cstd::integral_constant< bool, __is_trivial(_Tp)>
 Cstd::is_trivial< _Tp >Is_trivial
 Cstd::integral_constant< bool, __is_trivially_copyable(_Tp)>
 Cstd::integral_constant< bool, __is_union(_Tp)>
 Cstd::is_union< _Tp >Is_union
 Cstd::integral_constant< bool, _R1::num==_R2::num &&_R1::den==_R2::den >
 Cstd::ratio_equal< _R1, _R2 >Ratio_equal
 Cstd::integral_constant< bool, is_function< _Tp >::value >
 Cstd::integral_constant< bool, noexcept(_Tp())>
 Cstd::integral_constant< bool, noexcept(_Tp(declval< _Args >()...))>
 Cstd::integral_constant< bool, noexcept(declval< _Tp >()=declval< _Up >())>
 Cstd::integral_constant< bool, noexcept(static_cast< _Tp >(declval< _Arg >()))>
 Cstd::integral_constant< bool,(__hi1< __hi2||(__hi1==__hi2 &&__lo1< __lo2))>
 Cstd::value > 0)>
 Cstd::integral_constant< int, 0 >
 Cstd::is_placeholder< _Tp >Determines if the given type _Tp is a placeholder in a bind() expression and, if so, which placeholder it is
 Cstd::integral_constant< int, _Num >
 Cstd::is_placeholder< _Placeholder< _Num > >
 Cstd::integral_constant< intmax_t, __static_abs< _Pn >::value >
 Cstd::integral_constant< intmax_t, __static_abs< _Qn >::value >
 Cstd::integral_constant< intmax_t, _Pn *__static_sign< _Pn >::value >
 Cstd::integral_constant< intmax_t,(_Pn< 0) ? -1 :1 >
 Cstd::integral_constant< std::size_t, 0 >
 Cstd::extent< typename, _Uint >Extent
 Cstd::rank< typename >Rank
 Cstd::integral_constant< std::size_t, 1+rank< _Tp >::value >
 Cstd::integral_constant< std::size_t, 2 >
 Cstd::tuple_size< std::pair< _Tp1, _Tp2 > >Partial specialization for std::pair
 Cstd::integral_constant< std::size_t, _Nm >
 Cstd::tuple_size< std::__debug::array< _Tp, _Nm > >Tuple_size
 Cstd::tuple_size<::array< _Tp, _Nm > >Partial specialization for std::array
 Cstd::integral_constant< std::size_t, _Uint==0 ? 0 :extent< _Tp, _Uint - 1 >::value >
 Cstd::integral_constant< std::size_t, _Uint==0 ? _Size :extent< _Tp, _Uint - 1 >::value >
 Cstd::integral_constant< std::size_t, alignof(_Tp)>
 Cstd::alignment_of< _Tp >Alignment_of
 Cstd::integral_constant< std::size_t, sizeof...(_Elements)>
 Cstd::tuple_size< tuple< _Elements... > >Class tuple_size
 Cstd::integral_constant< unsigned, 0 >
 Cstd::integral_constant< unsigned, 1 >
 Cstd::integral_constant< unsigned, _Val >
 Cstd::is_floating_point< _Rep >
 Cstd::chrono::treat_as_floating_point< _Rep >Treat_as_floating_point
 Cstd::is_nothrow_assignable< _Tp &, _Tp && >
 Cstd::is_nothrow_assignable< _Tp &, const _Tp & >
 Cstd::is_nothrow_constructible< _Tp, _Tp && >
 Cstd::is_nothrow_constructible< _Tp, const _Tp & >
 Cstd::iterator< input_iterator_tag, _CharT, _Traits::off_type, _CharT *, _CharT >
 Cstd::istreambuf_iterator< _CharT, _Traits >Provides input iterator semantics for streambufs
 Cstd::iterator< input_iterator_tag, _Tp, _Dist, const _Tp *, const _Tp & >
 Cstd::istream_iterator< _Tp, _CharT, _Traits, _Dist >Provides input iterator semantics for streams
 Cstd::iterator< iterator_traits< _Iterator >::iterator_category, iterator_traits< _Iterator >::value_type, iterator_traits< _Iterator >::difference_type, iterator_traits< _Iterator >::pointer, iterator_traits< _Iterator >::reference >
 Cstd::reverse_iterator< _Iterator >
 Cstd::iterator< output_iterator_tag, void, void, void, void >
 Cstd::back_insert_iterator< _Container >Turns assignment into insertion
 Cstd::front_insert_iterator< _Container >Turns assignment into insertion
 Cstd::insert_iterator< _Container >Turns assignment into insertion
 Cstd::ostream_iterator< _Tp, _CharT, _Traits >Provides output iterator semantics for streams
 Cstd::ostreambuf_iterator< _CharT, _Traits >Provides output iterator semantics for streambufs
 Cstd::raw_storage_iterator< _OutputIterator, _Tp >
 Cstd::iterator< std::output_iterator_tag, void, void, void, void >
 Cstd::iterator< std::random_access_iterator_tag, _CharT >
 Cstd::iterator< std::random_access_iterator_tag, bool >
 C__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, _Alloc::size_type, _Alloc >
 C__gnu_pbds::detail::binomial_heap_base< Value_Type, Cmp_Fn, _Alloc >Base class for binomial heap
 C__gnu_pbds::detail::binomial_heap< Value_Type, Cmp_Fn, _Alloc >
 C__gnu_pbds::detail::rc_binomial_heap< Value_Type, Cmp_Fn, _Alloc >
 C__gnu_pbds::detail::thin_heap< Value_Type, Cmp_Fn, _Alloc >
 C__gnu_pbds::detail::left_child_next_sibling_heap< Value_Type, Cmp_Fn, null_type, _Alloc >
 C__gnu_pbds::detail::pairing_heap< Value_Type, Cmp_Fn, _Alloc >
 C__gnu_pbds::detail::lu_counter_policy_base< _Alloc::size_type >
 C__gnu_pbds::lu_counter_policy< Max_Count, _Alloc >
 Cstd::make_unsigned< _DiffT >
 Cstd::mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL >
 Cstd::normal_distribution< double >
 Cstd::normal_distribution< result_type >
 Cstd::pair< _Bi_iter, _Bi_iter >
 Cstd::sub_match< _Bi_iter >
 Cstd::pair< _BiIter, _BiIter >
 Cstd::sub_match< _BiIter >
 Cstd::pair< _Iterator1, _Iterator2 >
 C__gnu_parallel::_IteratorPair< _Iterator1, _Iterator2, _IteratorCategory >A pair of iterators. The usual iterator operations are applied to both child iterators
 Cstd::pair< _RAIter, _RAIter >
 Cstd::pair< char, _TokenT >
 Cstd::pair< char, char >
 Cstd::pair< entry_pointer, typename _Alloc::size_type >
 Cpoint_const_iterator_Const point-type iterator
 Cconst_iterator_Const range-type iterator
 Citerator_Range-type iterator
 Cpoint_iterator_Find type iterator
 C__gnu_pbds::detail::rc< typename binomial_heap_base< Value_Type, Cmp_Fn, _Alloc >::node, _Alloc >
 Cstd::regex_traits< _CharType >
 C__gnu_pbds::detail::resize_policy< _Alloc::size_type >
 C__gnu_pbds::detail::binary_heap< Value_Type, Cmp_Fn, _Alloc >
 Cstd::scoped_allocator_adaptor< _InnerHead, _InnerTail... >
 Cstd::shared_ptr< _Dir >
 Cstd::shared_ptr< _Dir_stack >
 Cstd::shared_ptr< _RegexT >
 Cstd::shared_ptr< _State >
 Cstd::shared_ptr< _State_base >
 Cstd::shared_ptr< _State_type >
 Cstd::shared_ptr< const __detail::_NFA< _Rx_traits > >
 Cstd::shared_ptr< std::mutex >
 Cstd::stack< _StateSeqT >
 Cstd::__add_pointer_helper< _Tp, bool >Add_pointer
 Cstd::__allocated_ptr< _Alloc >Non-standard RAII type for managing pointers obtained from allocators
 Cstd::__atomic_base< _ITp >Base class for atomic integrals
 Cstd::__atomic_base< _PTp * >Partial specialization for pointer types
 Cstd::__atomic_flag_baseBase type for atomic_flag
 Cstd::atomic_flagAtomic_flag
 Cstd::__debug::bitset< _Nb >Class std::bitset with additional safety/checking/debug instrumentation
 Cstd::__detail::_BracketMatcher< _TraitsT, __icase, __collate >Matches a character range (bracket expression)
 Cstd::__detail::_Compiler< _TraitsT >Builds an NFA from an input iterator range
 Cstd::__detail::_Default_ranged_hashDefault ranged hash function H. In principle it should be a function object composed from objects of type H1 and H2 such that h(k, N) = h2(h1(k), N), but that would mean making extra copies of h1 and h2. So instead we'll just use a tag to tell class template hashtable to do that composition
 Cstd::__detail::_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, __cache_hash_code >
 Cstd::__detail::_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, false >Specialization
 Cstd::__detail::_Equal_helper< _Key, _Value, _ExtractKey, _Equal, _HashCodeType, true >Specialization
 Cstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, _Unique_keys >
 Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
 Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
 Cstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true >Specialization
 Cstd::__detail::_Equality_base
 Cstd::__detail::_Equality< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false >Specialization
 Cstd::__detail::_Executor< _BiIter, _Alloc, _TraitsT, __dfs_mode >Takes a regex and an input string and does the matching
 Cstd::__detail::_Hash_code_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache_hash_code >
 Cstd::__detail::_Hash_node< _Value, _Cache_hash_code >
 Cstd::__detail::_Hash_node_base
 Cstd::__detail::_Hash_node_value_base< _Value >
 Cstd::__detail::_Hash_node< _Value, false >
 Cstd::__detail::_Hash_node< _Value, true >
 Cstd::__detail::_Hashtable_ebo_helper< _Nm, _Tp, __use_ebo >
 Cstd::__detail::_Hashtable_ebo_helper< _Nm, _Tp, false >Specialization not using EBO
 Cstd::__detail::_Hashtable_ebo_helper< _Nm, _Tp, true >Specialization using EBO
 Cstd::__detail::_Hashtable_traits< _Cache_hash_code, _Constant_iterators, _Unique_keys >
 Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, _Constant_iterators >
 Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
 Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
 Cstd::__detail::_Insert_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits >
 Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false >Specialization
 Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true >Specialization
 Cstd::__detail::_List_node_baseCommon part of a node in the list
 Cstd::__detail::_List_node_headerThe list node header
 Cstd::_List_node< _Tp >An actual node in the list
 Cstd::__detail::_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache_hash_code >
 Cstd::__detail::_Map_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, _Unique_keys >
 Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
 Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
 Cstd::__detail::_Map_base< _Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false >Partial specialization, __unique_keys set to false
 Cstd::__detail::_Map_base< _Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true >Partial specialization, __unique_keys set to true
 Cstd::__detail::_Mask_range_hashingRange hashing function assuming that second arg is a power of 2
 Cstd::__detail::_Mod_range_hashingDefault range hashing function: use division to fold a large number into the range [0, N)
 Cstd::__detail::_Node_iterator_base< _Value, _Cache_hash_code >Base class for node iterators
 Cstd::__detail::_Power2_rehash_policyRehash policy providing power of 2 bucket numbers. Avoids modulo operations
 Cstd::__detail::_Prime_rehash_policyDefault value for rehash policy. Bucket size is (usually) the smallest prime that keeps the load factor small enough
 Cstd::__detail::_Quoted_string< _String, _CharT >Struct for delimited strings
 Cstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, typename >
 Cstd::_Hashtable< _Key, _Tp, _Hash, _Pred, _Alloc >
 Cstd::_Hashtable< _Value, _Hash, _Pred, _Alloc >
 Cstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, std::false_type >Specialization when rehash policy doesn't provide load factor management
 Cstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, std::true_type >Specialization when rehash policy provide load factor management
 Cstd::__detail::_Scanner< _CharT >Scans an input range for regex tokens
 Cstd::__detail::_StateSeq< _TraitsT >Describes a sequence of one or more _State, its current start and end(s). This structure contains fragments of an NFA during construction
 Cstd::__detector< _Default, _AlwaysVoid, _Op, _Args >Implementation of the detection idiom (negative case)
 Cstd::__detector< _Default, __void_t< _Op< _Args... > >, _Op, _Args... >Implementation of the detection idiom (positive case)
 Cstd::__exception_ptr::exception_ptrAn opaque pointer to an arbitrary exception
 Cstd::__future_baseBase class and enclosing scope
 Cstd::__basic_future< _Res & >
 Cstd::future< _Res & >Partial specialization for future<R&>
 Cstd::shared_future< _Res & >Partial specialization for shared_future<R&>
 Cstd::__basic_future< void >
 Cstd::future< void >Explicit specialization for future<void>
 Cstd::shared_future< void >Explicit specialization for shared_future<void>
 Cstd::__basic_future< _Res >Common implementation for future and shared_future
 Cstd::future< _Res >Primary template for future
 Cstd::shared_future< _Res >Primary template for shared_future
 Cstd::__future_base::_Result_baseBase class for results
 Cstd::__future_base::_Result< _Res >A result object that has storage for an object of type _Res
 Cstd::__future_base::_Result_alloc< _Res, _Alloc >A result object that uses an allocator
 Cstd::__future_base::_Result< _Res & >Partial specialization for reference types
 Cstd::__future_base::_Result< void >Explicit specialization for void
 Cstd::__is_location_invariant< _Tp >
 Cstd::__is_trivially_copy_assignable_impl< _Tp, bool >Is_trivially_copy_assignable
 Cstd::__is_trivially_copy_constructible_impl< _Tp, bool >Is_trivially_copy_constructible
 Cstd::__is_trivially_move_assignable_impl< _Tp, bool >Is_trivially_move_assignable
 Cstd::__is_trivially_move_constructible_impl< _Tp, bool >Is_trivially_move_constructible
 Cstd::__iterator_traits< _Iterator, typename >Traits class for iterators
 Cstd::__numeric_limits_basePart of std::numeric_limits
 Cstd::numeric_limits< _Tp >Properties of fundamental types
 Cstd::__parallel::_CRandNumber< _MustBeInt >Functor wrapper for std::rand()
 Cstd::__profile::bitset< _Nb >Class std::bitset wrapper with performance instrumentation, none at the moment
 Cstd::__profile::deque< _Tp, _Allocator >Class std::deque wrapper with performance instrumentation
 Cstd::__profile::forward_list< _Tp, _Alloc >Class std::forward_list wrapper with performance instrumentation
 Cstd::__profile::list< _Tp, _Allocator >List wrapper with performance instrumentation
 Cstd::__profile::map< _Key, _Tp, _Compare, _Allocator >Class std::map wrapper with performance instrumentation
 Cstd::__profile::multimap< _Key, _Tp, _Compare, _Allocator >Class std::multimap wrapper with performance instrumentation
 Cstd::__profile::multiset< _Key, _Compare, _Allocator >Class std::multiset wrapper with performance instrumentation
 Cstd::__profile::set< _Key, _Compare, _Allocator >Class std::set wrapper with performance instrumentation
 Cstd::__profile::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_map wrapper with performance instrumentation
 Cstd::__profile::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >Class std::unordered_multimap wrapper with performance instrumentation
 Cstd::__profile::unordered_multiset< _Value, _Hash, _Pred, _Alloc >Unordered_multiset wrapper with performance instrumentation
 Cstd::__profile::unordered_set< _Key, _Hash, _Pred, _Alloc >Unordered_set wrapper with performance instrumentation
 Cstd::__shared_mutex_cvA shared mutex type implemented using std::condition_variable
 Cstd::shared_timed_mutexThe standard shared timed mutex type
 Cstd::_Base_bitset< _Nw >
 Cstd::_Base_bitset< 0 >
 Cstd::_Base_bitset< 1 >
 Cstd::_Bind< _Signature >Type of the function object returned from bind()
 Cstd::_Bind_result< _Result, _Signature >Type of the function object returned from bind<R>()
 Cstd::_Deque_base< _Tp, _Alloc >
 Cstd::deque< _Tp, _Alloc >A standard container using fixed-size memory allocation and constant-time manipulation of elements at either end
 Cstd::_Deque_iterator< _Tp, _Ref, _Ptr >A deque::iterator
 Cstd::_Enable_copy_move< _Copy, _CopyAssignment, _Move, _MoveAssignment, _Tag >A mixin helper to conditionally enable or disable the copy/move special members
 Cstd::_Enable_special_members< _Default, _Destructor, _Copy, _CopyAssignment, _Move, _MoveAssignment, _Tag >A mixin helper to conditionally enable or disable the special members
 Cstd::_Enable_default_constructor< _Switch, _Tag >A mixin helper to conditionally enable or disable the default constructor
 Cstd::_Enable_destructor< _Switch, _Tag >A mixin helper to conditionally enable or disable the default destructor
 Cstd::_Function_baseBase class of all polymorphic function object wrappers
 Cstd::function< _Res(_ArgTypes...)>Primary class template for std::function.Polymorphic function wrapper
 Cstd::_Fwd_list_base< _Tp, _Alloc >Base class for forward_list
 Cstd::forward_list< _Tp, _Alloc >A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
 Cstd::_Fwd_list_const_iterator< _Tp >A forward_list::const_iterator
 Cstd::_Fwd_list_iterator< _Tp >A forward_list::iterator
 Cstd::_Fwd_list_node_baseA helper basic node class for forward_list. This is just a linked list with nothing inside it. There are purely list shuffling utility methods here
 Cstd::_Fwd_list_node< _Tp >A helper node class for forward_list. This is just a linked list with uninitialized storage for a data value in each node. There is a sorting utility method
 Cstd::_List_base< _Tp, _Alloc >See bits/stl_deque.h's _Deque_base for an explanation
 Cstd::list< _Tp, _Alloc >A standard container with linear time access to elements, and fixed time insertion/deletion at any point in the sequence
 Cstd::_List_const_iterator< _Tp >A list::const_iterator
 Cstd::_List_iterator< _Tp >A list::iterator
 Cstd::_Maybe_get_result_type< _Functor, typename >If we have found a result_type, extract it
 Cstd::_Maybe_unary_or_binary_function< _Res, _ArgTypes >
 Cstd::_Mu< _Arg, _IsBindExp, _IsPlaceholder >
 Cstd::_Mu< _Arg, false, false >
 Cstd::_Mu< _Arg, false, true >
 Cstd::_Mu< _Arg, true, false >
 Cstd::_Mu< reference_wrapper< _Tp >, false, false >
 Cstd::_Not_fn< _Fn >Generalized negator
 Cstd::_Placeholder< _Num >The type of placeholder objects defined by libstdc++
 Cstd::_Sp_ebo_helper< _Nm, _Tp, false >Specialization not using EBO
 Cstd::_Sp_ebo_helper< _Nm, _Tp, true >Specialization using EBO
 Cstd::_Temporary_buffer< _ForwardIterator, _Tp >
 C__gnu_cxx::temporary_buffer< _ForwardIterator, _Tp >
 Cstd::_Tuple_impl< _Idx, _Elements >
 Cstd::_V2::condition_variable_anyCondition_variable_any
 Cstd::_V2::error_categoryError_category
 Cstd::_Vector_base< _Tp, _Alloc >See bits/stl_deque.h's _Deque_base for an explanation
 Cstd::vector< _Tp, _Alloc >A standard container which offers fixed time access to individual elements in any order
 Cstd::_Weak_result_type< _Functor >
 Cstd::_Weak_result_type_impl< _Res(*)(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL >Retrieve the result type for a function pointer
 Cstd::_Weak_result_type_impl< _Res(*)(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL >Retrieve the result type for a varargs function pointer
 Cstd::_Weak_result_type_impl< _Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL >Retrieve the result type for a function type
 Cstd::_Weak_result_type_impl< _Res(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL >Retrieve the result type for a varargs function type
 Cstd::add_const< _Tp >Add_const
 Cstd::add_cv< _Tp >Add_cv
 Cstd::add_lvalue_reference< _Tp >Add_lvalue_reference
 Cstd::add_rvalue_reference< _Tp >Add_rvalue_reference
 Cstd::add_volatile< _Tp >Add_volatile
 Cstd::adopt_lock_tAssume the calling thread has already obtained mutex ownership and manage it
 Cstd::aligned_storage< _Len, _Align >Alignment type
 Cstd::aligned_union< _Len, _Types >Provide aligned storage for types
 Cstd::allocator< void >Allocator<void> specialization
 Cstd::allocator_arg_t[allocator.tag]
 Cstd::allocator_traits< _Alloc >Uniform interface to all allocator types
 C__gnu_cxx::__alloc_traits< _Alloc, typename >Uniform interface to C++98 and C++11 allocators
 Cstd::allocator_traits< allocator< _Tp > >Partial specialization for std::allocator
 Cstd::array< _Tp, _Nm >A standard container for storing a fixed size sequence of elements
 Cstd::atomic< _Tp >Generic atomic type, primary class template
 Cstd::atomic< _Tp * >Partial specialization for pointer types
 Cstd::atomic< bool >Atomic<bool>
 Cstd::auto_ptr< _Tp >A simple smart pointer providing strict ownership semantics
 Cstd::auto_ptr_ref< _Tp1 >
 Cstd::basic_istream< _CharT, _Traits >::sentryPerforms setup work for input streams
 Cstd::basic_ostream< _CharT, _Traits >::sentryPerforms setup work for output streams
 Cstd::basic_regex< _Ch_type, _Rx_traits >
 Cstd::basic_streambuf< _CharT, _Traits >The actual work of input and output (interface)
 C__gnu_cxx::stdio_sync_filebuf< _CharT, _Traits >Provides a layer of compatibility for C.This GNU extension provides extensions for working with standard C FILE*'s. It must be instantiated by the user with the type of character used in the file stream, e.g., stdio_filebuf<char>
 Cstd::basic_filebuf< _CharT, encoding_char_traits< _CharT > >
 C__gnu_cxx::enc_filebuf< _CharT >Class enc_filebuf
 Cstd::basic_filebuf< char_type, traits_type >
 Cstd::basic_filebuf< _CharT, _Traits >The actual work of input and output (for files)
 C__gnu_cxx::stdio_filebuf< _CharT, _Traits >Provides a layer of compatibility for C/POSIX.This GNU extension provides extensions for working with standard C FILE*'s and POSIX file descriptors. It must be instantiated by the user with the type of character used in the file stream, e.g., stdio_filebuf<char>
 Cstd::basic_stringbuf< _CharT, _Traits, _Alloc >The actual work of input and output (for std::string)
 Cstd::basic_string< _CharT, _Traits, _Alloc >Managing sequences of characters and character-like objects
 Cstd::bernoulli_distributionA Bernoulli random number distribution
 Cstd::bernoulli_distribution::param_type
 Cstd::binary_function< _Arg1, _Arg2, _Result >
 Cstd::pointer_to_binary_function< _Arg1, _Arg2, _Result >One of the adaptors for function pointers
 Cstd::binomial_distribution< _IntType >A discrete binomial random number distribution
 Cstd::binomial_distribution< _IntType >::param_type
 Cstd::bitset< _Nb >::reference
 Cstd::cauchy_distribution< _RealType >A cauchy_distribution random number distribution
 Cstd::cauchy_distribution< _RealType >::param_type
 Cstd::char_traits< __gnu_cxx::character< _Value, _Int, _St > >Char_traits<__gnu_cxx::character> specialization
 Cstd::char_traits< char >21.1.3.1 char_traits specializations
 Cstd::char_traits< wchar_t >21.1.3.2 char_traits specializations
 Cstd::chi_squared_distribution< _RealType >A chi_squared_distribution random number distribution
 Cstd::chi_squared_distribution< _RealType >::param_type
 Cstd::chrono::_V2::steady_clockMonotonic clock
 Cstd::chrono::_V2::system_clockSystem clock
 Cstd::chrono::duration< _Rep, _Period >Duration
 Cstd::chrono::duration_values< _Rep >Duration_values
 Cstd::chrono::time_point< _Clock, _Dur >Time_point
 Cstd::codecvt_baseEmpty base class for codecvt facet [22.2.1.5]
 Cstd::__codecvt_abstract_base< _InternT, _ExternT, encoding_state >
 Cstd::codecvt< _InternT, _ExternT, encoding_state >Codecvt<InternT, _ExternT, encoding_state> specialization
 Cstd::__codecvt_abstract_base< char, char, mbstate_t >
 Cstd::codecvt< char, char, mbstate_t >Class codecvt<char, char, mbstate_t> specialization
 Cstd::__codecvt_abstract_base< char16_t, char, mbstate_t >
 Cstd::codecvt< char16_t, char, mbstate_t >Class codecvt<char16_t, char, mbstate_t> specialization
 Cstd::__codecvt_abstract_base< char32_t, char, mbstate_t >
 Cstd::codecvt< char32_t, char, mbstate_t >Class codecvt<char32_t, char, mbstate_t> specialization
 Cstd::__codecvt_abstract_base< wchar_t, char, mbstate_t >
 Cstd::codecvt< wchar_t, char, mbstate_t >Class codecvt<wchar_t, char, mbstate_t> specialization
 Cstd::__codecvt_abstract_base< _InternT, _ExternT, _StateT >Common base for codecvt functions
 Cstd::codecvt< _Elem, char, mbstate_t >
 Cstd::codecvt< _InternT, _ExternT, _StateT >Primary class template codecvt.NB: Generic, mostly useless implementation
 Cstd::codecvt_byname< _InternT, _ExternT, _StateT >Class codecvt_byname [22.2.1.6]
 Cstd::common_type< _Tp >Common_type
 Cstd::complex< _Tp >
 Cstd::complex< double >26.2.3 complex specializations complex<double> specialization
 Cstd::complex< float >26.2.3 complex specializations complex<float> specialization
 Cstd::complex< long double >26.2.3 complex specializations complex<long double> specialization
 Cstd::condition_variableCondition_variable
 Cstd::conditional< _Cond, _Iftrue, _Iffalse >Define a member typedef type to one of two argument types
 Cstd::ctype_baseBase class for ctype
 Cstd::__ctype_abstract_base< wchar_t >
 Cstd::ctype< wchar_t >The ctype<wchar_t> specialization.This class defines classification and conversion functions for the wchar_t type. It gets used by wchar_t streams for many I/O operations. The wchar_t specialization provides a number of optimizations as well
 Cstd::__ctype_abstract_base< _CharT >Common base for ctype facet
 Cstd::ctype< _CharT >Primary class template ctype facet.This template class defines classification and conversion functions for character sets. It wraps cctype functionality. Ctype gets used by streams for many I/O operations
 Cstd::ctype_byname< _CharT >Class ctype_byname [22.2.1.2]
 Cstd::ctype< char >The ctype<char> specialization.This class defines classification and conversion functions for the char type. It gets used by char streams for many I/O operations. The char specialization provides a number of optimizations as well
 Cstd::ctype_byname< char >22.2.1.4 Class ctype_byname specializations
 Cstd::decay< _Tp >Decay
 Cstd::decimal::decimal1283.2.4 Class decimal128
 Cstd::decimal::decimal323.2.2 Class decimal32
 Cstd::decimal::decimal643.2.3 Class decimal64
 Cstd::default_delete< _Tp >Primary template of default_delete, used by unique_ptr
 Cstd::default_delete< _Tp[]>Specialization for arrays, default_delete
 Cstd::defer_lock_tDo not acquire ownership of the mutex
 Cstd::discard_block_engine< _RandomNumberEngine, __p, __r >
 Cstd::discrete_distribution< _IntType >A discrete_distribution random number distribution
 Cstd::discrete_distribution< _IntType >::param_type
 Cstd::divides< void >One of the math functors
 Cstd::enable_if< bool, _Tp >Define a member typedef type only if a boolean constant is true
 Cstd::enable_shared_from_this< _Tp >Base class allowing use of member function shared_from_this
 Cstd::equal_to< void >One of the comparison functors
 Cstd::error_codeError_code
 Cstd::error_conditionError_condition
 Cstd::exceptionBase class for all library exceptions
 C__gnu_cxx::forced_errorThown by exception safety machinery
 C__gnu_cxx::recursive_init_errorException thrown by __cxa_guard_acquire.C++ 2011 6.7 [stmt.dcl]/4: If control re-enters the declaration recursively while the variable is being initialized, the behavior is undefined
 Cstd::bad_allocException possibly thrown by new.bad_alloc (or classes derived from it) is used to report allocation errors from the throwing forms of new
 Cstd::bad_castThrown during incorrect typecasting.If you attempt an invalid dynamic_cast expression, an instance of this class (or something derived from this class) is thrown
 Cstd::experimental::fundamentals_v1::bad_any_castException class thrown by a failed any_cast
 Cstd::bad_exception
 Cstd::bad_function_callException class thrown when class template function's operator() is called with an empty target
 Cstd::bad_typeidThrown when a NULL pointer in a typeid expression is used
 Cstd::bad_weak_ptrException possibly thrown by shared_ptr
 Cstd::ios_base::failureThese are thrown to indicate problems with io.27.4.2.1.1 Class ios_base::failure
 Cstd::logic_errorOne of two subclasses of exception
 C__gnu_pbds::container_errorBase class for exceptions
 C__gnu_pbds::insert_errorAn entry cannot be inserted into a container object for logical reasons (not, e.g., if memory is unabvailable, in which case the allocator_type's exception will be thrown)
 C__gnu_pbds::join_errorA join cannot be performed logical reasons (i.e., the ranges of the two container objects being joined overlaps
 C__gnu_pbds::resize_errorA container cannot be resized
 Cstd::domain_error
 Cstd::experimental::fundamentals_v1::bad_optional_accessException class thrown when a disengaged optional object is dereferenced
 Cstd::future_errorException type thrown by futures
 Cstd::invalid_argument
 Cstd::length_error
 Cstd::out_of_range
 Cstd::runtime_errorOne of two subclasses of exception
 Cstd::overflow_error
 Cstd::range_error
 Cstd::regex_errorA regular expression exception class.The regular expression library throws objects of this class on error
 Cstd::system_errorThrown to indicate error code of underlying system
 Cstd::underflow_error
 Cstd::experimental::filesystem::v1::pathA filesystem path
 Cstd::experimental::filesystem::v1::path::iteratorAn iterator for the components of a path
 Cstd::experimental::fundamentals_v1::_Has_addressof< _Tp >Trait that detects the presence of an overloaded unary operator&
 Cstd::experimental::fundamentals_v1::_Optional_base< _Tp, _ShouldProvideDestructor >Class template that holds the necessary state for Optional values and that has the responsibility for construction and the special members
 Cstd::experimental::fundamentals_v1::_Optional_base< _Tp, false >Partial specialization that is exactly identical to the primary template save for not providing a destructor, to fulfill triviality requirements
 Cstd::experimental::fundamentals_v1::anyA type-safe container of any type
 Cstd::experimental::fundamentals_v1::basic_string_view< _CharT, _Traits >A non-owning reference to a string
 Cstd::experimental::fundamentals_v1::in_place_tTag type for in-place construction
 Cstd::experimental::fundamentals_v1::nullopt_tTag type to disengage optional objects
 Cstd::experimental::fundamentals_v2::ostream_joiner< _DelimT, _CharT, _Traits >Output iterator that inserts a delimiter between elements
 Cstd::experimental::fundamentals_v2::owner_less< shared_ptr< _Tp > >Partial specialization of owner_less for shared_ptr
 Cstd::experimental::fundamentals_v2::owner_less< weak_ptr< _Tp > >Partial specialization of owner_less for weak_ptr
 Cstd::experimental::fundamentals_v2::propagate_const< _Tp >Const-propagating wrapper
 Cstd::exponential_distribution< _RealType >An exponential continuous distribution for random numbers
 Cstd::exponential_distribution< _RealType >::param_type
 Cstd::extreme_value_distribution< _RealType >A extreme_value_distribution random number distribution
 Cstd::extreme_value_distribution< _RealType >::param_type
 Cstd::fisher_f_distribution< _RealType >A fisher_f_distribution random number distribution
 Cstd::fisher_f_distribution< _RealType >::param_type
 Cstd::fpos< _StateT >Class representing stream positions
 Cstd::gamma_distribution< _RealType >A gamma continuous distribution for random numbers
 Cstd::gamma_distribution< _RealType >::param_type
 Cstd::geometric_distribution< _IntType >A discrete geometric random number distribution
 Cstd::geometric_distribution< _IntType >::param_type
 Cstd::greater< void >One of the comparison functors
 Cstd::greater_equal< void >One of the comparison functors
 Cstd::gsliceClass defining multi-dimensional subset of an array
 Cstd::gslice_array< _Tp >Reference to multi-dimensional subset of an array
 Cstd::hash< _Tp >Primary class template hash
 Cstd::hash< __debug::bitset< _Nb > >Std::hash specialization for bitset
 Cstd::hash< __debug::vector< bool, _Alloc > >Std::hash specialization for vector<bool>
 Cstd::hash< __gnu_cxx::__u16vstring >Std::hash specialization for __u16vstring
 Cstd::hash< __gnu_cxx::__u32vstring >Std::hash specialization for __u32vstring
 Cstd::hash< __gnu_cxx::__vstring >Std::hash specialization for __vstring
 Cstd::hash< __gnu_cxx::__wvstring >Std::hash specialization for __wvstring
 Cstd::hash< __profile::bitset< _Nb > >Std::hash specialization for bitset
 Cstd::hash< __profile::vector< bool, _Alloc > >Std::hash specialization for vector<bool>
 Cstd::hash< __shared_ptr< _Tp, _Lp > >Std::hash specialization for __shared_ptr
 Cstd::hash< _Tp * >Partial specializations for pointer types
 Cstd::hash< bool >Explicit specialization for bool
 Cstd::hash< char >Explicit specialization for char
 Cstd::hash< char16_t >Explicit specialization for char16_t
 Cstd::hash< char32_t >Explicit specialization for char32_t
 Cstd::hash< double >Specialization for double
 Cstd::hash< error_code >Std::hash specialization for error_code
 Cstd::hash< experimental::shared_ptr< _Tp > >Std::hash specialization for shared_ptr
 Cstd::hash< float >Specialization for float
 Cstd::hash< int >Explicit specialization for int
 Cstd::hash< long >Explicit specialization for long
 Cstd::hash< long double >Specialization for long double
 Cstd::hash< long long >Explicit specialization for long long
 Cstd::hash< shared_ptr< _Tp > >Std::hash specialization for shared_ptr
 Cstd::hash< short >Explicit specialization for short
 Cstd::hash< signed char >Explicit specialization for signed char
 Cstd::hash< string >Std::hash specialization for string
 Cstd::hash< thread::id >Std::hash specialization for thread::id
 Cstd::hash< type_index >Std::hash specialization for type_index
 Cstd::hash< u16string >Std::hash specialization for u16string
 Cstd::hash< u32string >Std::hash specialization for u32string
 Cstd::hash< unique_ptr< _Tp, _Dp > >Std::hash specialization for unique_ptr
 Cstd::hash< unsigned char >Explicit specialization for unsigned char
 Cstd::hash< unsigned int >Explicit specialization for unsigned int
 Cstd::hash< unsigned long >Explicit specialization for unsigned long
 Cstd::hash< unsigned long long >Explicit specialization for unsigned long long
 Cstd::hash< unsigned short >Explicit specialization for unsigned short
 Cstd::hash< wchar_t >Explicit specialization for wchar_t
 Cstd::hash< wstring >Std::hash specialization for wstring
 Cstd::hash<::bitset< _Nb > >Std::hash specialization for bitset
 Cstd::hash<::vector< bool, _Alloc > >Std::hash specialization for vector<bool>
 Cstd::independent_bits_engine< _RandomNumberEngine, __w, _UIntType >
 Cstd::indirect_array< _Tp >Reference to arbitrary subset of an array
 Cstd::initializer_list< _E >Initializer_list
 Cstd::input_iterator_tagMarking input iterators
 Cstd::forward_iterator_tagForward iterators support a superset of input iterator operations
 Cstd::bidirectional_iterator_tagBidirectional iterators support a superset of forward iterator operations
 Cstd::random_access_iterator_tagRandom-access iterators support a superset of bidirectional iterator operations
 Cstd::integer_sequence< _Tp, _Idx >Class template integer_sequence
 Cstd::integral_constant< _Tp, __v >Integral_constant
 Cstd::is_assignable< _Tp &, _Tp && >
 Cstd::is_assignable< _Tp &, const _Tp & >
 Cstd::is_constructible< _Tp, _Tp && >
 Cstd::is_constructible< _Tp, const _Tp & >
 Cstd::__is_tuple_like_impl< std::pair< _T1, _T2 > >Partial specialization for std::pair
 Cstd::is_array< typename >Is_array
 Cstd::is_assignable< _Tp, _Up >Is_assignable
 Cstd::is_bind_expression< _Tp >Determines if the given type _Tp is a function object that should be treated as a subexpression when evaluating calls to function objects returned by bind()
 Cstd::is_bind_expression< _Bind< _Signature > >Class template _Bind is always a bind expression
 Cstd::is_bind_expression< _Bind_result< _Result, _Signature > >Class template _Bind_result is always a bind expression
 Cstd::is_bind_expression< const _Bind< _Signature > >Class template _Bind is always a bind expression
 Cstd::is_bind_expression< const _Bind_result< _Result, _Signature > >Class template _Bind_result is always a bind expression
 Cstd::is_bind_expression< const volatile _Bind< _Signature > >Class template _Bind is always a bind expression
 Cstd::is_bind_expression< const volatile _Bind_result< _Result, _Signature > >Class template _Bind_result is always a bind expression
 Cstd::is_bind_expression< volatile _Bind< _Signature > >Class template _Bind is always a bind expression
 Cstd::is_bind_expression< volatile _Bind_result< _Result, _Signature > >Class template _Bind_result is always a bind expression
 Cstd::is_const< typename >Is_const
 Cstd::is_constructible< _Tp, _Args >Is_constructible
 Cstd::is_default_constructible< _Tp >Is_default_constructible
 Cstd::is_error_code_enum< _Tp >Is_error_code_enum
 Cstd::is_error_code_enum< future_errc >Specialization
 Cstd::is_error_condition_enum< _Tp >Is_error_condition_enum
 Cstd::is_function< typename >Is_function
 Cstd::is_integral< _Tp >Is_integral
 Cstd::is_lvalue_reference< typename >Is_lvalue_reference
 Cstd::is_member_function_pointer< _Tp >Is_member_function_pointer
 Cstd::is_member_pointer< _Tp >Is_member_pointer
 Cstd::is_object< _Tp >Is_object
 Cstd::is_rvalue_reference< typename >Is_rvalue_reference
 Cstd::is_same< typename, typename >Is_same
 Cstd::is_trivially_assignable< _Tp, _Up >Is_trivially_assignable
 Cstd::is_void< _Tp >Is_void
 Cstd::is_volatile< typename >Is_volatile
 Cstd::uses_allocator< tuple< _Types... >, _Alloc >Partial specialization for tuples
 Cstd::ios_baseThe base of the I/O class hierarchy.This class defines everything that can be defined about I/O that does not depend on the type of characters being input or output. Most people will only see ios_base when they need to specify the full name of the various I/O flags (e.g., the openmodes)
 Cstd::basic_ios< char, _Traits >
 Cstd::basic_istream< char >
 Cstd::basic_istream< char, _Traits >
 Cstd::basic_iostream< char >
 Cstd::basic_ostream< char >
 Cstd::basic_ostream< char, _Traits >
 Cstd::basic_iostream< char >
 Cstd::basic_ios< _CharT, _Traits >Template class basic_ios, virtual base class for all stream classes
 Cstd::basic_istream< _CharT, _Traits >Template class basic_istream
 Cstd::basic_ifstream< _CharT, _Traits >Controlling input for files
 Cstd::basic_iostream< _CharT, _Traits >Template class basic_iostream
 Cstd::basic_fstream< _CharT, _Traits >Controlling input and output for files
 Cstd::basic_stringstream< _CharT, _Traits, _Alloc >Controlling input and output for std::string
 Cstd::basic_istringstream< _CharT, _Traits, _Alloc >Controlling input for std::string
 Cstd::basic_ostream< _CharT, _Traits >Template class basic_ostream
 Cstd::basic_iostream< _CharT, _Traits >Template class basic_iostream
 Cstd::basic_ofstream< _CharT, _Traits >Controlling output for files
 Cstd::basic_ostringstream< _CharT, _Traits, _Alloc >Controlling output for std::string
 Cstd::is_arithmetic< _Tp >Is_arithmetic
 Cstd::is_convertible< _From, _To >Is_convertible
 Cstd::is_copy_assignable< _Tp >Is_copy_assignable
 Cstd::is_copy_constructible< _Tp >Is_copy_constructible
 Cstd::is_destructible< _Tp >Is_destructible
 Cstd::is_floating_point< _Tp >Is_floating_point
 Cstd::is_fundamental< _Tp >Is_fundamental
 Cstd::is_member_object_pointer< _Tp >Is_member_object_pointer
 Cstd::is_move_assignable< _Tp >Is_move_assignable
 Cstd::is_move_constructible< _Tp >Is_move_constructible
 Cstd::is_nothrow_assignable< _Tp, _Up >Is_nothrow_assignable
 Cstd::is_nothrow_constructible< _Tp, _Args >Is_nothrow_constructible
 Cstd::is_nothrow_copy_assignable< _Tp >Is_nothrow_copy_assignable
 Cstd::is_nothrow_copy_constructible< _Tp >Is_nothrow_copy_constructible
 Cstd::is_nothrow_default_constructible< _Tp >Is_nothrow_default_constructible
 Cstd::is_nothrow_destructible< _Tp >Is_nothrow_destructible
 Cstd::is_nothrow_move_assignable< _Tp >Is_nothrow_move_assignable
 Cstd::is_nothrow_move_constructible< _Tp >Is_nothrow_move_constructible
 Cstd::is_nothrow_swappable< _Tp >Is_nothrow_swappable
 Cstd::is_nothrow_swappable_with< _Tp, _Up >Is_nothrow_swappable_with
 Cstd::is_null_pointer< _Tp >Is_null_pointer (LWG 2247)
 Cstd::__is_nullptr_t< _Tp >__is_nullptr_t (extension)
 Cstd::is_pointer< _Tp >Is_pointer
 Cstd::is_reference< _Tp >Is_reference
 Cstd::is_scalar< _Tp >Is_scalar
 Cstd::is_swappable< _Tp >Metafunctions used for detecting swappable types: p0185r1
 Cstd::is_swappable_with< _Tp, _Up >Is_swappable_with
 Cstd::is_trivially_constructible< _Tp, _Args >Is_trivially_constructible
 Cstd::is_trivially_default_constructible< _Tp >Is_trivially_default_constructible
 Cstd::is_trivially_destructible< _Tp >Is_trivially_destructible
 Cstd::iterator< _Category, _Tp, _Distance, _Pointer, _Reference >Common iterator class
 Cstd::iterator_traits< _Tp * >Partial specialization for pointer types
 Cstd::iterator_traits< const _Tp * >Partial specialization for const pointer types
 Cstd::less< void >One of the comparison functors
 Cstd::less_equal< void >One of the comparison functors
 Cstd::linear_congruential_engine< _UIntType, __a, __c, __m >A model of a linear congruential random number generator
 Cstd::localeContainer class for localization functionality.The locale class is first a class wrapper for C library locales. It is also an extensible container for user-defined localization. A locale is a collection of facets that implement various localization features such as money, time, and number printing
 Cstd::locale::facetLocalization functionality base class.The facet class is the base class for a localization feature, such as money, time, and number printing. It provides common support for facets and reference management
 Cstd::__codecvt_abstract_base< _InternT, _ExternT, encoding_state >
 Cstd::__codecvt_abstract_base< char, char, mbstate_t >
 Cstd::__codecvt_abstract_base< char16_t, char, mbstate_t >
 Cstd::__codecvt_abstract_base< char32_t, char, mbstate_t >
 Cstd::__codecvt_abstract_base< wchar_t, char, mbstate_t >
 Cstd::__ctype_abstract_base< wchar_t >
 Cstd::__codecvt_abstract_base< _InternT, _ExternT, _StateT >Common base for codecvt functions
 Cstd::__ctype_abstract_base< _CharT >Common base for ctype facet
 Cstd::collate< _CharT >Facet for localized string comparison
 Cstd::collate_byname< _CharT >Class collate_byname [22.2.4.2]
 Cstd::ctype< char >The ctype<char> specialization.This class defines classification and conversion functions for the char type. It gets used by char streams for many I/O operations. The char specialization provides a number of optimizations as well
 Cstd::messages< _CharT >Primary class template messages.This facet encapsulates the code to retrieve messages from message catalogs. The only thing defined by the standard for this facet is the interface. All underlying functionality is implementation-defined
 Cstd::messages_byname< _CharT >Class messages_byname [22.2.7.2]
 Cstd::money_get< _CharT, _InIter >Primary class template money_get.This facet encapsulates the code to parse and return a monetary amount from a string
 Cstd::money_put< _CharT, _OutIter >Primary class template money_put.This facet encapsulates the code to format and output a monetary amount
 Cstd::moneypunct< _CharT, _Intl >Primary class template moneypunct.This facet encapsulates the punctuation, grouping and other formatting features of money amount string representations
 Cstd::moneypunct_byname< _CharT, _Intl >Class moneypunct_byname [22.2.6.4]
 Cstd::num_get< _CharT, _InIter >Primary class template num_get.This facet encapsulates the code to parse and return a number from a string. It is used by the istream numeric extraction operators
 Cstd::num_put< _CharT, _OutIter >Primary class template num_put.This facet encapsulates the code to convert a number to a string. It is used by the ostream numeric insertion operators
 Cstd::numpunct< _CharT >Primary class template numpunct.This facet stores several pieces of information related to printing and scanning numbers, such as the decimal point character. It takes a template parameter specifying the char type. The numpunct facet is used by streams for many I/O operations involving numbers
 Cstd::numpunct_byname< _CharT >Class numpunct_byname [22.2.3.2]
 Cstd::time_get< _CharT, _InIter >Primary class template time_get.This facet encapsulates the code to parse and return a date or time from a string. It is used by the istream numeric extraction operators
 Cstd::time_get_byname< _CharT, _InIter >Class time_get_byname [22.2.5.2]
 Cstd::time_put< _CharT, _OutIter >Primary class template time_put.This facet encapsulates the code to format and output dates and times according to formats used by strftime()
 Cstd::time_put_byname< _CharT, _OutIter >Class time_put_byname [22.2.5.4]
 Cstd::locale::idFacet ID class.The ID class provides facets with an index used to identify them. Every facet class must define a public static member locale::id, or be derived from a facet that provides this member, otherwise the facet cannot be used in a locale. The locale::id ensures that each class type gets a unique identifier
 Cstd::lock_guard< _Mutex >A simple scoped lock type
 Cstd::logical_and< void >One of the Boolean operations functors
 Cstd::logical_not< void >One of the Boolean operations functors
 Cstd::logical_or< void >One of the Boolean operations functors
 Cstd::lognormal_distribution< _RealType >A lognormal_distribution random number distribution
 Cstd::lognormal_distribution< _RealType >::param_type
 Cstd::make_signed< _Tp >Make_signed
 Cstd::make_unsigned< _Tp >Make_unsigned
 Cstd::map< _Key, _Tp, _Compare, _Alloc >A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
 Cstd::mask_array< _Tp >Reference to selected subset of an array
 Cstd::mersenne_twister_engine< _UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f >
 Cstd::messages_baseMessages facet base class providing catalog typedef
 Cstd::messages< _CharT >Primary class template messages.This facet encapsulates the code to retrieve messages from message catalogs. The only thing defined by the standard for this facet is the interface. All underlying functionality is implementation-defined
 Cstd::minus< void >One of the math functors
 Cstd::modulus< void >One of the math functors
 Cstd::money_baseMoney format ordering data.This class contains an ordered array of 4 fields to represent the pattern for formatting a money amount. Each field may contain one entry from the part enum. symbol, sign, and value must be present and the remaining field must contain either none or space
 Cstd::moneypunct< _CharT, _Intl >Primary class template moneypunct.This facet encapsulates the punctuation, grouping and other formatting features of money amount string representations
 Cstd::move_iterator< _Iterator >
 Cstd::multimap< _Key, _Tp, _Compare, _Alloc >A standard container made up of (key,value) pairs, which can be retrieved based on a key, in logarithmic time
 Cstd::multiplies< void >One of the math functors
 Cstd::multiset< _Key, _Compare, _Alloc >A standard container made up of elements, which can be retrieved in logarithmic time
 Cstd::mutexThe standard mutex type
 Cstd::negate< void >One of the math functors
 Cstd::negative_binomial_distribution< _IntType >A negative_binomial_distribution random number distribution
 Cstd::negative_binomial_distribution< _IntType >::param_type
 Cstd::nested_exceptionException class with exception_ptr data member
 Cstd::normal_distribution< _RealType >A normal continuous distribution for random numbers
 Cstd::normal_distribution< _RealType >::param_type
 Cstd::not_equal_to< void >One of the comparison functors
 Cstd::numeric_limits< bool >Numeric_limits<bool> specialization
 Cstd::numeric_limits< char >Numeric_limits<char> specialization
 Cstd::numeric_limits< char16_t >Numeric_limits<char16_t> specialization
 Cstd::numeric_limits< char32_t >Numeric_limits<char32_t> specialization
 Cstd::numeric_limits< double >Numeric_limits<double> specialization
 Cstd::numeric_limits< float >Numeric_limits<float> specialization
 Cstd::numeric_limits< int >Numeric_limits<int> specialization
 Cstd::numeric_limits< long >Numeric_limits<long> specialization
 Cstd::numeric_limits< long double >Numeric_limits<long double> specialization
 Cstd::numeric_limits< long long >Numeric_limits<long long> specialization
 Cstd::numeric_limits< short >Numeric_limits<short> specialization
 Cstd::numeric_limits< signed char >Numeric_limits<signed char> specialization
 Cstd::numeric_limits< unsigned char >Numeric_limits<unsigned char> specialization
 Cstd::numeric_limits< unsigned int >Numeric_limits<unsigned int> specialization
 Cstd::numeric_limits< unsigned long >Numeric_limits<unsigned long> specialization
 Cstd::numeric_limits< unsigned long long >Numeric_limits<unsigned long long> specialization
 Cstd::numeric_limits< unsigned short >Numeric_limits<unsigned short> specialization
 Cstd::numeric_limits< wchar_t >Numeric_limits<wchar_t> specialization
 Cstd::once_flagOnce_flag
 Cstd::output_iterator_tagMarking output iterators
 Cstd::owner_less< _Tp >Primary template owner_less
 Cstd::owner_less< shared_ptr< _Tp > >Partial specialization of owner_less for shared_ptr
 Cstd::owner_less< void >Void specialization of owner_less
 Cstd::owner_less< weak_ptr< _Tp > >Partial specialization of owner_less for weak_ptr
 Cstd::packaged_task< _Res(_ArgTypes...)>Packaged_task
 Cstd::pair< _T1, _T2 >Struct holding two objects of arbitrary type
 Cstd::piecewise_constant_distribution< _RealType >A piecewise_constant_distribution random number distribution
 Cstd::piecewise_constant_distribution< _RealType >::param_type
 Cstd::piecewise_construct_tPiecewise_construct_t
 Cstd::piecewise_linear_distribution< _RealType >A piecewise_linear_distribution random number distribution
 Cstd::piecewise_linear_distribution< _RealType >::param_type
 Cstd::pointer_traits< _Ptr >Uniform interface to all pointer-like types
 Cstd::pointer_traits< _Tp * >Partial specialization for built-in pointers
 Cstd::poisson_distribution< _IntType >A discrete Poisson random number distribution
 Cstd::poisson_distribution< _IntType >::param_type
 Cstd::priority_queue< _Tp, _Sequence, _Compare >A standard container automatically sorting its contents
 Cstd::promise< _Res >Primary template for promise
 Cstd::promise< _Res & >Partial specialization for promise<R&>
 Cstd::promise< void >Explicit specialization for promise<void>
 Cstd::queue< _Tp, _Sequence >A standard container giving FIFO behavior
 Cstd::random_device
 Cstd::ratio< _Num, _Den >Provides compile-time rational arithmetic
 Cstd::recursive_mutexThe standard recursive mutex type
 Cstd::recursive_timed_mutexRecursive_timed_mutex
 Cstd::reference_wrapper< _Tp >Primary class template for reference_wrapper
 Cstd::regex_iterator< _Bi_iter, _Ch_type, _Rx_traits >
 Cstd::regex_token_iterator< _Bi_iter, _Ch_type, _Rx_traits >
 Cstd::regex_traits< _Ch_type >Describes aspects of a regular expression
 Cstd::remove_all_extents< _Tp >Remove_all_extents
 Cstd::remove_const< _Tp >Remove_const
 Cstd::remove_cv< _Tp >Remove_cv
 Cstd::remove_extent< _Tp >Remove_extent
 Cstd::remove_pointer< _Tp >Remove_pointer
 Cstd::remove_reference< _Tp >Remove_reference
 Cstd::remove_volatile< _Tp >Remove_volatile
 Cstd::result_of< _Signature >Result_of
 Cstd::scoped_allocator_adaptor< _OuterAlloc, _InnerAllocs >Primary class template
 Cstd::seed_seqGenerates sequences of seeds for random number generators
 Cstd::set< _Key, _Compare, _Alloc >A standard container made up of unique keys, which can be retrieved in logarithmic time
 Cstd::shared_lock< _Mutex >Shared_lock
 Cstd::shared_ptr< _Tp >A smart pointer with reference-counted copy semantics
 Cstd::shuffle_order_engine< _RandomNumberEngine, __k >Produces random numbers by combining random numbers from some base engine to produce random numbers with a specifies number of bits __k
 Cstd::sliceClass defining one-dimensional subset of an array
 Cstd::slice_array< _Tp >Reference to one-dimensional subset of an array
 Cstd::stack< _Tp, _Sequence >A standard container giving FILO behavior
 Cstd::student_t_distribution< _RealType >A student_t_distribution random number distribution
 Cstd::student_t_distribution< _RealType >::param_type
 Cstd::subtract_with_carry_engine< _UIntType, __w, __s, __r >The Marsaglia-Zaman generator
 Cstd::threadThread
 Cstd::thread::idThread::id
 Cstd::time_baseTime format ordering data.This class provides an enum representing different orderings of time: day, month, and year
 Cstd::time_get< _CharT, _InIter >Primary class template time_get.This facet encapsulates the code to parse and return a date or time from a string. It is used by the istream numeric extraction operators
 Cstd::timed_mutexTimed_mutex
 Cstd::tr2::__dynamic_bitset_base< _WordT, _Alloc >
 Cstd::tr2::dynamic_bitset< _WordT, _Alloc >The dynamic_bitset class represents a sequence of bits
 Cstd::tr2::__reflection_typelist< _Elements >
 Cstd::tr2::__reflection_typelist< _First, _Rest... >Partial specialization
 Cstd::tr2::__reflection_typelist<>Specialization for an empty typelist
 Cstd::tr2::bases< _Tp >Sequence abstraction metafunctions for manipulating a typelist
 Cstd::tr2::bool_set
 Cstd::tr2::direct_bases< _Tp >Enumerate all the direct base classes of a class. Form of a typelist
 Cstd::tr2::dynamic_bitset< _WordT, _Alloc >::reference
 Cstd::try_to_lock_tTry to acquire ownership of the mutex without blocking
 Cstd::tuple_element< _Int, _Tp >Tuple_element
 Cstd::tuple_element< 0, std::pair< _Tp1, _Tp2 > >Partial specialization for std::pair
 Cstd::tuple_element< 0, tuple< _Head, _Tail... > >
 Cstd::tuple_element< 1, std::pair< _Tp1, _Tp2 > >Partial specialization for std::pair
 Cstd::tuple_element< __i, tuple<> >
 Cstd::tuple_element< _Int, ::array< _Tp, _Nm > >Partial specialization for std::array
 Cstd::tuple_element< _Int, std::__debug::array< _Tp, _Nm > >Tuple_element
 Cstd::tuple_size< _Tp >Tuple_size
 Cstd::type_indexClass type_indexThe class type_index provides a simple wrapper for type_info which can be used as an index type in associative containers (23.6) and in unordered associative containers (23.7)
 Cstd::type_infoPart of RTTI
 Cstd::unary_function< _Arg, _Result >
 C__gnu_cxx::binary_compose< _Operation1, _Operation2, _Operation3 >An SGI extension
 C__gnu_cxx::subtractive_rng
 C__gnu_cxx::unary_compose< _Operation1, _Operation2 >An SGI extension
 Cstd::pointer_to_unary_function< _Arg, _Result >One of the adaptors for function pointers
 Cstd::underlying_type< _Tp >The underlying type of an enum
 Cstd::uniform_int_distribution< _IntType >Uniform discrete distribution for random numbers. A discrete random distribution on the range $[min, max]$ with equal probability throughout the range
 Cstd::uniform_int_distribution< _IntType >::param_type
 Cstd::uniform_real_distribution< _RealType >Uniform continuous distribution for random numbers
 Cstd::uniform_real_distribution< _RealType >::param_type
 Cstd::unique_lock< _Mutex >A movable scoped lock type
 Cstd::unique_ptr< _Tp, _Dp >20.7.1.2 unique_ptr for single objects
 Cstd::unique_ptr< _Tp[], _Dp >20.7.1.3 unique_ptr for array objects with a runtime length
 Cstd::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >A standard container composed of unique keys (containing at most one of each key value) that associates values of another type with the keys
 Cstd::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >A standard container composed of equivalent keys (possibly containing multiple of each key value) that associates values of another type with the keys
 Cstd::unordered_multiset< _Value, _Hash, _Pred, _Alloc >A standard container composed of equivalent keys (possibly containing multiple of each key value) in which the elements' keys are the elements themselves
 Cstd::unordered_set< _Value, _Hash, _Pred, _Alloc >A standard container composed of unique keys (containing at most one of each key value) in which the elements' keys are the elements themselves
 Cstd::uses_allocator< _Tp, _Alloc >Declare uses_allocator so it can be specialized in <queue> etc
 Cstd::valarray< _Tp >Smart array designed to support numeric processing
 Cstd::vector< bool, _Alloc >A specialization of vector for booleans which offers fixed time access to individual elements in any order
 Cstd::weak_ptr< _Tp >A smart pointer with weak semantics
 Cstd::weibull_distribution< _RealType >A weibull_distribution random number distribution
 Cstd::weibull_distribution< _RealType >::param_type
 Cstd::wstring_convert< _Codecvt, _Elem, _Wide_alloc, _Byte_alloc >String conversions
 Cstd::chrono::time_point< _Clock, _Duration >
 Cstd::tuple_element< __i - 1, tuple< _Tail... > >
 Cstd::tuple_element< __i, tuple< _Head, _Tail... > >
 Cstd::unary_function< __gnu_cxx::throw_value_limit, size_t >
 Cstd::hash< __gnu_cxx::throw_value_limit >Explicit specialization of std::hash for __gnu_cxx::throw_value_limit
 Cstd::unary_function< __gnu_cxx::throw_value_random, size_t >
 Cstd::hash< __gnu_cxx::throw_value_random >Explicit specialization of std::hash for __gnu_cxx::throw_value_random
 Cstd::unary_function< _FirstArgumentType, _ResultType >
 C__gnu_parallel::__binder2nd< _Operation, _FirstArgumentType, _SecondArgumentType, _ResultType >Similar to std::binder2nd, but giving the argument types explicitly
 Cstd::unary_function< _Functor::argument_type, _Functor::result_type >
 Cstd::unary_function< _Operation2::argument_type, _Operation1::result_type >
 Cstd::unary_function< _Operation::first_argument_type, _Operation::result_type >
 Cstd::binder2nd< _Operation >One of the binder functors
 Cstd::unary_function< _Operation::second_argument_type, _Operation::result_type >
 Cstd::binder1st< _Operation >One of the binder functors
 Cstd::unary_function< _Pair, _Pair::first_type >
 Cstd::unary_function< _Pair, _Pair::second_type >
 Cstd::unary_function< _Predicate::argument_type, bool >
 Cstd::unary_negate< _Predicate >One of the negation functors
 Cstd::unary_function< _SecondArgumentType, _ResultType >
 C__gnu_parallel::__binder1st< _Operation, _FirstArgumentType, _SecondArgumentType, _ResultType >Similar to std::binder1st, but giving the argument types explicitly
 Cstd::unary_function< _T1, _Res >
 Cstd::_Maybe_unary_or_binary_function< _Res, _T1 >Derives from unary_function, as appropriate
 Cstd::unary_function< _Tp *, _Ret >
 Cstd::mem_fun_t< _Ret, _Tp >One of the adaptors for member pointers
 Cstd::unary_function< _Tp, _Ret >
 Cstd::const_mem_fun_ref_t< _Ret, _Tp >One of the adaptors for member pointers
 Cstd::mem_fun_ref_t< _Ret, _Tp >One of the adaptors for member pointers
 Cstd::unary_function< _Tp, _Tp >
 Cstd::negate< _Tp >One of the math functors
 Cstd::unary_function< _Tp, bool >
 Cstd::logical_not< _Tp >One of the Boolean operations functors
 Cstd::unary_function< _Value, _Value >
 Cstd::unary_function< argument_type, bool >
 C__gnu_parallel::__unary_negate< _Predicate, argument_type >Similar to std::unary_negate, but giving the argument types explicitly
 Cstd::unary_function< const _Tp *, _Ret >
 Cstd::const_mem_fun_t< _Ret, _Tp >One of the adaptors for member pointers
 Cstd::unary_function< pair< const _Key, _Tp >, pair< const _Key, _Tp > ::first_type >
 Cstd::unary_function< std::pair< _Tp, _Tp >, bool >
 C__gnu_cxx::__detail::_Ffit_finder< _Tp >The class which acts as a predicate for applying the first-fit memory allocation policy for the bitmap allocator
 Cstd::unary_function< unsigned int, unsigned int >
 Cstd::unique_ptr< _Codecvt >
 Cstd::unique_ptr< _Res_type >
 Cstd::unique_ptr< _Result< _Res > >
 Cstd::unique_ptr< _Result_base >
 Cstd::unique_ptr< bool[]>
 Cstd::unordered_map< _Key, _Tp, _Hash, _Pred >
 Cstd::valarray< _Dom::value_type >
 Cstd::valarray< size_t >
 Cstd::weak_ptr< _State_baseV2 >