":282" = "---";















":324" = "---";



":333" = "---";


":344" = "The iterator category is at least a forward iterator.";

":348" = "---";

":357" = "The iterator category is at least a forward iterator.";




":370" = "Postconditions:;; `size() == 0` Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].";
":373" = "---";



":387" = "Postconditions:;; `size() == 0` Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].";
":390" = "---";


":406" = "Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].";
":408" = "---";





":422" = "---";



":434" = "---";



":445" = "Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].";
":447" = "---";



":456" = "---";



":465" = "---";



":479" = "---";




":497" = "---";


":512" = "Requires:;; If the defaults are used, `hasher`, `key_equal` and `allocator_type` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].";
":514" = "---";




":527" = "---";




":540" = "---";


":552" = "Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].";
":554" = "---";


":567" = "Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].";
":569" = "---";



":580" = "Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].";
":582" = "---";



":593" = "Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].";
":595" = "---";



":607" = "Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].";
":609" = "---";



":620" = "---";




":635" = "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^]";
":637" = "---";


":654" = "---";



":664" = "Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInsertable[CopyInsertable^]";




":678" = "---";



":689" = "---";



":700" = "---";



":710" = "---";




":723" = "---";



":734" = "---";



":745" = "---";



":754" = "Inserts an object, constructed with the arguments `args`, in the container if and only if there is no element in the container with an equivalent key.";
":757" = "Requires:;; `value_type` is constructible from `args`. Returns:;; The `bool` component of the return type is `true` if an insert took place. + + If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. + + If `args...` is of the form `k,v`, it delays constructing the whole object until it is certain that an element should be inserted, using only the `k` argument to check.";
":766" = "---";


":773" = "Inserts an object, constructed with the arguments `args`, in the container if and only if there is no element in the container with an equivalent key.";

":778" = "Requires:;; `value_type` is constructible from `args`. Returns:;; The `bool` component of the return type is `true` if an insert took place. + + If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key. Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect. Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. + + If `args...` is of the form `k,v`, it delays constructing the whole object until it is certain that an element should be inserted, using only the `k` argument to check.";
":787" = "---";


":795" = "Inserts `obj` in the container if and only if there is no element in the container with an equivalent key.";

":807" = "---";


":815" = "Inserts `obj` in the container if and only if there is no element in the container with an equivalent key.";

":827" = "---";


":836" = "`hint` is a suggestion to where the element should be inserted. This implementation ignores it.";

":848" = "---";


":856" = "Inserts `obj` in the container if and only if there is no element in the container with an equivalent key.";
":858" = "`hint` is a suggestion to where the element should be inserted. This implementation ignores it.";

":870" = "---";


":877" = "Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key.";

":884" = "---";


":891" = "Inserts a range of elements into the container. Elements are inserted if and only if there is no element in the container with an equivalent key.";

":898" = "---";


":910" = "Inserts a new element into the container if there is no existing element with key `k` contained within it.";
":912" = "If there is an existing element with key `k` this function does nothing.";

":925" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))";
":930" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```";

":937" = "Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load.";
":939" = "The `template<class K, class\\... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.";
":941" = "--";
":943" = "---";


":955" = "Inserts a new element into the container if there is no existing element with key `k` contained within it.";
":957" = "If there is an existing element with key `k` this function does nothing.";


":970" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<Args>(args)...))";
":975" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<Args>(args)...)) ```";

":982" = "Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load.";
":984" = "The `template<class K, class\\... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.";
":986" = "--";
":988" = "---";


":1000" = "Inserts a new element into the container or updates an existing one by assigning to the contained value.";
":1002" = "If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.";
":1004" = "If there is no such element, it is added to the container as: ```c++";
":1007" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj)))";
":1012" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<M>(obj))) ```";

":1026" = "---";


":1038" = "Inserts a new element into the container or updates an existing one by assigning to the contained value.";
":1040" = "If there is an element with key `k`, then it is updated by assigning `std::forward<M>(obj)`.";
":1042" = "If there is no such element, it is added to the container as: ```c++";
":1045" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<Key>(k)), std::forward_as_tuple(std::forward<M>(obj)))";
":1050" = "value_type(std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), std::forward_as_tuple(std::forward<M>(obj))) ```";
":1055" = "`hint` is a suggestion to where the element should be inserted. This implementation ignores it.";

":1064" = "---";



":1083" = "---";




":1098" = "---";




":1112" = "---";



":1123" = "If `Allocator::propagate_on_container_swap` is declared and `Allocator::propagate_on_container_swap::value` is `true` then the containers' allocators are swapped. Otherwise, swapping with unequal allocators results in undefined behavior.";

":1128" = "---";



":1138" = "---";




":1150" = "---";



":1162" = "---";




":1174" = "---";



":1184" = "---";



":1194" = "---";





":1211" = "---";



":1224" = "---";



":1237" = "---";



":1253" = "---";



":1270" = "---";



":1285" = "---";




":1297" = "---";




":1309" = "---";



":1320" = "---";



":1330" = "---";



":1344" = "---";




":1355" = "Invalidates iterators, pointers and references, and changes the order of elements.";
":1358" = "Throws:;; The function has no effect if an exception is thrown, unless it is thrown by the container's hash function or comparison function.";
":1360" = "---";




":1371" = "Invalidates iterators, pointers and references, and changes the order of elements.";
":1374" = "Throws:;; The function has no effect if an exception is thrown, unless it is thrown by the container's hash function or comparison function.";
":1376" = "---";




":1389" = "---";



":1400" = "---";












":1459" = "Notes:;; Behavior is undefined if the two containers don't have equivalent equality predicates.";
":1461" = "---";



":1473" = "Notes:;; Behavior is undefined if the two containers don't have equivalent equality predicates.";



":1485" = "If `Allocator::propagate_on_container_swap` is declared and `Allocator::propagate_on_container_swap::value` is `true` then the containers' allocators are swapped. Otherwise, swapping with unequal allocators results in undefined behavior.";

":1491" = "---";









":1537" = "---";



":1548" = "---";



":1560" = "---";