libstdc++
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 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: http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch32.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< V, I, S >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::debug_allocator< _Alloc >A meta-allocator with debugging bits, as per [20.4].This is precisely the allocator defined in the C++ Standard
 C__gnu_cxx::enc_filebuf< _CharT >Class enc_filebuf
 C__gnu_cxx::encoding_stateExtension to use iconv for dealing with character encodings
 C__gnu_cxx::forced_errorThown by exception safety machinery
 ▼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::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::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::recursive_init_errorException thrown by __cxa_guard_acquire.6.7[stmt.dcl]/4: If control re-enters the declaration (recursively) while the object is being initialized, the behavior is undefined
 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>
 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>
 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_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_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_sequence< map< _Key, _Tp, _Compare, _Allocator > >
 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 > >
 Cstd::__debug::multimap< _Key, _Tp, _Compare, _Allocator >Class std::multimap with safety/checking/debug instrumentation
 ▼C__gnu_debug::_Safe_sequence< multiset< _Key, _Compare, _Allocator > >
 Cstd::__debug::multiset< _Key, _Compare, _Allocator >Class std::multiset with safety/checking/debug instrumentation
 ▼C__gnu_debug::_Safe_sequence< set< _Key, _Compare, _Allocator > >
 Cstd::__debug::set< _Key, _Compare, _Allocator >Class std::set with safety/checking/debug instrumentation
 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_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
 ▼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::__stack_info_base< __object_info >Base class for a line in the stack table
 C__gnu_profile::__trace_base< __object_info, __stack_info >Base class for all trace producers
 C__gnu_profile::__warning_dataRepresentation of a warning
 ▼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::__detail::_Before_begin< _Node_allocator_type >
 C__gnu_cxx::__detail::_Bitmap_counter< _Alloc_block * >
 Cstd::_Deque_iterator< _Tp, _Tp &, _Tp * >
 ▼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, _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::_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, false >Specialization
 ▼Cstd::__detail::_Hashtable_ebo_helper< 0, _H2 >
 Cstd::__detail::_Local_iterator_base< _Key, _Value, _ExtractKey, _H1, _H2, _Hash, true >Specialization
 ▼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::__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
 C__gnu_parallel::_RestrictedBoundedConcurrentQueue< pair< _RAIter, _RAIter > >
 ▼Cstd::_Vector_base< __gnu_parallel::_Piece< _DifferenceType >, std::allocator< __gnu_parallel::_Piece< _DifferenceType > > >
 Cstd::vector< __gnu_parallel::_Piece< _DifferenceType > >
 ▼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, std::allocator< _State > >
 ▼Cstd::vector< _State >
 Cstd::__detail::_NfaStruct _Nfa
 ▼Cstd::_Vector_base< _StateSeq, std::allocator< _StateSeq > >
 Cstd::vector< _StateSeq >
 ▼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< 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::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_string< _CharT >
 Cstd::basic_string< char >
 ▼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< _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, 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, _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< 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< weak_ptr< _Tp >, weak_ptr< _Tp >, bool >
 ▼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::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::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::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< _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< 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 >
 ▼C__gnu_pbds::detail::resize_policy< _Alloc::size_type >
 C__gnu_pbds::detail::binary_heap< Value_Type, Cmp_Fn, _Alloc >
 Cstd::set< _StateIdT >
 Cstd::shared_ptr< _Automaton >
 Cstd::shared_ptr< std::__detail::_Nfa >
 Cstd::stack< _StateSeq, std::vector< _StateSeq > >
 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::__detail::_AutomatonBase class for, um, automata. Could be an NFA or a DFA. Your choice
 Cstd::__detail::_NfaStruct _Nfa
 Cstd::__detail::_Before_begin< _NodeAlloc >
 Cstd::__detail::_CharMatcher< _InIterT, _TraitsT >Matches a single character
 Cstd::__detail::_Compiler< _InIter, _TraitsT >Builds an NFA from an input iterator interval
 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::_EndTagger< _FwdIterT, _TraitsT >End state tag
 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::_Grep_matcherExecutes a regular expression NFA/DFA over a range using a variant of the parallel execution algorithm featured in the grep utility, modified to use Laurikari tags
 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, 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, _Unique_keys >
 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, _Unique_keys >Specialization
 Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true, false >Specialization
 Cstd::__detail::_Insert< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true, true >Specialization
 ▼Cstd::__detail::_List_node_baseCommon part of a node in the list
 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::_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::_PatternCursorABC for pattern matching
 Cstd::__detail::_SpecializedCursor< _FwdIterT >Provides a cursor into the specific target string
 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::_RangeMatcher< _InIterT, _TraitsT >Matches a character range (bracket expression)
 ▼Cstd::__detail::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _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::_Rehash_base< _Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _Prime_rehash_policy, _Traits >Specialization
 ▼Cstd::__detail::_ResultsProvides a generic facade for a templated match_results
 Cstd::__detail::_SpecializedResults< _FwdIterT, _Alloc >A _Results facade specialized for wrapping a templated match_results
 ▼Cstd::__detail::_Scanner_baseBase class for scanner
 Cstd::__detail::_Scanner< _InIter >
 Cstd::__detail::_Scanner< _InputIterator >Struct _Scanner. Scans an input range for regex tokens
 Cstd::__detail::_StartTagger< _FwdIterT, _TraitsT >Start state tag
 Cstd::__detail::_StateStruct _State
 Cstd::__detail::_StateSeqDescribes a sequence of one or more _State, its current start and end(s). This structure contains fragments of an NFA during construction
 Cstd::__exception_ptr::exception_ptrAn opaque pointer to an arbitrary exception
 Cstd::__has_iterator_category_helper< _Tp >Traits class for iterators
 Cstd::__parallel::_CRandNumber< _MustBeInt >Functor wrapper for std::rand()
 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::_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::_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::_Temporary_buffer< _ForwardIterator, _Tp >
 ▼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::match_results< _Bi_iter >
 Cstd::match_results< _FwdIterT, _Alloc >
 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 >Uniform interface to C++98 and C++0x allocators
 Cstd::auto_ptr< _Tp >A simple smart pointer providing strict ownership semantics
 Cstd::auto_ptr_ref< _Tp1 >
 Cstd::bad_weak_ptrException possibly thrown by shared_ptr
 Cstd::basic_regex< _Ch_type, _Rx_traits >
 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::cauchy_distribution< _RealType >A cauchy_distribution random number distribution
 Cstd::cauchy_distribution< _RealType >::param_type
 Cstd::char_traits< __gnu_cxx::character< V, I, S > >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::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< 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< _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::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::default_delete< _Tp >Primary template, default_delete
 Cstd::default_delete< _Tp[]>Specialization, default_delete
 Cstd::discard_block_engine< _RandomNumberEngine, __p, __r >
 Cstd::discrete_distribution< _IntType >A discrete_distribution random number distribution
 Cstd::discrete_distribution< _IntType >::param_type
 Cstd::enable_shared_from_this< _Tp >Base class allowing use of member function shared_from_this
 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::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< __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< __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< 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< 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<::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::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::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< _CharT, _Traits >Template class basic_ios, virtual base class for all stream classes
 Cstd::ios_base::failureThese are thrown to indicate problems with io.27.4.2.1.1 Class ios_base::failure
 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::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< 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::lognormal_distribution< _RealType >A lognormal_distribution random number distribution
 Cstd::lognormal_distribution< _RealType >::param_type
 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::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::multiset< _Key, _Compare, _Alloc >A standard container made up of elements, which can be retrieved in logarithmic time
 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::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< weak_ptr< _Tp > >Partial specialization of owner_less for weak_ptr
 ▼Cstd::pair< _T1, _T2 >Struct holding two objects of arbitrary type
 Cstd::sub_match< _Bi_iter >
 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::queue< _Tp, _Sequence >A standard container giving FIFO behavior
 Cstd::random_device
 Cstd::regex_errorA regular expression exception class.The regular expression library throws objects of this class on error
 Cstd::regex_iterator< _Bi_iter, _Ch_type, _Rx_traits >
 Cstd::regex_token_iterator< _Bi_iter, _Ch_type, _Rx_traits >
 Cstd::regex_traits< _Ch_type >Class regex_traits. Describes aspects of a regular expression
 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_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 __w
 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::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::unary_function< _Arg, _Result >
 Cstd::pointer_to_unary_function< _Arg, _Result >One of the adaptors for function pointers
 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_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::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::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_limit
 ▼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< _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< _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< 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< 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