Restoring authorship annotation for Andrey Khalyavin <halyavin@gmail.com>. Commit 2 of 2.

1 files changed, 1575 insertions, 1575 deletions

diff --git a/contrib/libs/cxxsupp/libcxx/include/unordered_set b/contrib/libs/cxxsupp/libcxx/include/unordered_set
index a78c70f519..5856e4bc40 100644
--- a/contrib/libs/cxxsupp/libcxx/include/unordered_set
+++ b/contrib/libs/cxxsupp/libcxx/include/unordered_set
@@ -1,131 +1,131 @@
-// -*- C++ -*- 
-//===-------------------------- unordered_set -----------------------------===// 
-// 
+// -*- C++ -*-
+//===-------------------------- unordered_set -----------------------------===//
+//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef _LIBCPP_UNORDERED_SET 
-#define _LIBCPP_UNORDERED_SET 
- 
-/* 
- 
-    unordered_set synopsis 
- 
-#include <initializer_list> 
- 
-namespace std 
-{ 
- 
-template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, 
-          class Alloc = allocator<Value>> 
-class unordered_set 
-{ 
-public: 
-    // types 
-    typedef Value                                                      key_type; 
-    typedef key_type                                                   value_type; 
-    typedef Hash                                                       hasher; 
-    typedef Pred                                                       key_equal; 
-    typedef Alloc                                                      allocator_type; 
-    typedef value_type&                                                reference; 
-    typedef const value_type&                                          const_reference; 
-    typedef typename allocator_traits<allocator_type>::pointer         pointer; 
-    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer; 
-    typedef typename allocator_traits<allocator_type>::size_type       size_type; 
-    typedef typename allocator_traits<allocator_type>::difference_type difference_type; 
- 
-    typedef /unspecified/ iterator; 
-    typedef /unspecified/ const_iterator; 
-    typedef /unspecified/ local_iterator; 
-    typedef /unspecified/ const_local_iterator; 
- 
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_UNORDERED_SET
+#define _LIBCPP_UNORDERED_SET
+
+/*
+
+    unordered_set synopsis
+
+#include <initializer_list>
+
+namespace std
+{
+
+template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+          class Alloc = allocator<Value>>
+class unordered_set
+{
+public:
+    // types
+    typedef Value                                                      key_type;
+    typedef key_type                                                   value_type;
+    typedef Hash                                                       hasher;
+    typedef Pred                                                       key_equal;
+    typedef Alloc                                                      allocator_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    typedef typename allocator_traits<allocator_type>::pointer         pointer;
+    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
+    typedef typename allocator_traits<allocator_type>::size_type       size_type;
+    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+
+    typedef /unspecified/ iterator;
+    typedef /unspecified/ const_iterator;
+    typedef /unspecified/ local_iterator;
+    typedef /unspecified/ const_local_iterator;
+
     typedef unspecified node_type unspecified;                            // C++17
     typedef INSERT_RETURN_TYPE<iterator, node_type> insert_return_type;   // C++17
 
-    unordered_set() 
-        noexcept( 
-            is_nothrow_default_constructible<hasher>::value && 
-            is_nothrow_default_constructible<key_equal>::value && 
-            is_nothrow_default_constructible<allocator_type>::value); 
-    explicit unordered_set(size_type n, const hasher& hf = hasher(), 
-                           const key_equal& eql = key_equal(), 
-                           const allocator_type& a = allocator_type()); 
-    template <class InputIterator> 
-        unordered_set(InputIterator f, InputIterator l, 
-                      size_type n = 0, const hasher& hf = hasher(), 
-                      const key_equal& eql = key_equal(), 
-                      const allocator_type& a = allocator_type()); 
-    explicit unordered_set(const allocator_type&); 
-    unordered_set(const unordered_set&); 
-    unordered_set(const unordered_set&, const Allocator&); 
-    unordered_set(unordered_set&&) 
-        noexcept( 
-            is_nothrow_move_constructible<hasher>::value && 
-            is_nothrow_move_constructible<key_equal>::value && 
-            is_nothrow_move_constructible<allocator_type>::value); 
-    unordered_set(unordered_set&&, const Allocator&); 
-    unordered_set(initializer_list<value_type>, size_type n = 0, 
-                  const hasher& hf = hasher(), const key_equal& eql = key_equal(), 
-                  const allocator_type& a = allocator_type()); 
-    unordered_set(size_type n, const allocator_type& a); // C++14 
-    unordered_set(size_type n, const hasher& hf, const allocator_type& a); // C++14 
-    template <class InputIterator> 
-      unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14 
-    template <class InputIterator> 
+    unordered_set()
+        noexcept(
+            is_nothrow_default_constructible<hasher>::value &&
+            is_nothrow_default_constructible<key_equal>::value &&
+            is_nothrow_default_constructible<allocator_type>::value);
+    explicit unordered_set(size_type n, const hasher& hf = hasher(),
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& a = allocator_type());
+    template <class InputIterator>
+        unordered_set(InputIterator f, InputIterator l,
+                      size_type n = 0, const hasher& hf = hasher(),
+                      const key_equal& eql = key_equal(),
+                      const allocator_type& a = allocator_type());
+    explicit unordered_set(const allocator_type&);
+    unordered_set(const unordered_set&);
+    unordered_set(const unordered_set&, const Allocator&);
+    unordered_set(unordered_set&&)
+        noexcept(
+            is_nothrow_move_constructible<hasher>::value &&
+            is_nothrow_move_constructible<key_equal>::value &&
+            is_nothrow_move_constructible<allocator_type>::value);
+    unordered_set(unordered_set&&, const Allocator&);
+    unordered_set(initializer_list<value_type>, size_type n = 0,
+                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+                  const allocator_type& a = allocator_type());
+    unordered_set(size_type n, const allocator_type& a); // C++14
+    unordered_set(size_type n, const hasher& hf, const allocator_type& a); // C++14
+    template <class InputIterator>
+      unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14
+    template <class InputIterator>
       unordered_set(InputIterator f, InputIterator l, size_type n,
-                    const hasher& hf,  const allocator_type& a); // C++14 
-    unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14 
-    unordered_set(initializer_list<value_type> il, size_type n, 
-                  const hasher& hf,  const allocator_type& a); // C++14 
-    ~unordered_set(); 
-    unordered_set& operator=(const unordered_set&); 
-    unordered_set& operator=(unordered_set&&) 
-        noexcept( 
-            allocator_type::propagate_on_container_move_assignment::value && 
-            is_nothrow_move_assignable<allocator_type>::value && 
-            is_nothrow_move_assignable<hasher>::value && 
-            is_nothrow_move_assignable<key_equal>::value); 
-    unordered_set& operator=(initializer_list<value_type>); 
- 
-    allocator_type get_allocator() const noexcept; 
- 
-    bool      empty() const noexcept; 
-    size_type size() const noexcept; 
-    size_type max_size() const noexcept; 
- 
-    iterator       begin() noexcept; 
-    iterator       end() noexcept; 
-    const_iterator begin()  const noexcept; 
-    const_iterator end()    const noexcept; 
-    const_iterator cbegin() const noexcept; 
-    const_iterator cend()   const noexcept; 
- 
-    template <class... Args> 
-        pair<iterator, bool> emplace(Args&&... args); 
-    template <class... Args> 
-        iterator emplace_hint(const_iterator position, Args&&... args); 
-    pair<iterator, bool> insert(const value_type& obj); 
-    pair<iterator, bool> insert(value_type&& obj); 
-    iterator insert(const_iterator hint, const value_type& obj); 
-    iterator insert(const_iterator hint, value_type&& obj); 
-    template <class InputIterator> 
-        void insert(InputIterator first, InputIterator last); 
-    void insert(initializer_list<value_type>); 
- 
+                    const hasher& hf,  const allocator_type& a); // C++14
+    unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
+    unordered_set(initializer_list<value_type> il, size_type n,
+                  const hasher& hf,  const allocator_type& a); // C++14
+    ~unordered_set();
+    unordered_set& operator=(const unordered_set&);
+    unordered_set& operator=(unordered_set&&)
+        noexcept(
+            allocator_type::propagate_on_container_move_assignment::value &&
+            is_nothrow_move_assignable<allocator_type>::value &&
+            is_nothrow_move_assignable<hasher>::value &&
+            is_nothrow_move_assignable<key_equal>::value);
+    unordered_set& operator=(initializer_list<value_type>);
+
+    allocator_type get_allocator() const noexcept;
+
+    bool      empty() const noexcept;
+    size_type size() const noexcept;
+    size_type max_size() const noexcept;
+
+    iterator       begin() noexcept;
+    iterator       end() noexcept;
+    const_iterator begin()  const noexcept;
+    const_iterator end()    const noexcept;
+    const_iterator cbegin() const noexcept;
+    const_iterator cend()   const noexcept;
+
+    template <class... Args>
+        pair<iterator, bool> emplace(Args&&... args);
+    template <class... Args>
+        iterator emplace_hint(const_iterator position, Args&&... args);
+    pair<iterator, bool> insert(const value_type& obj);
+    pair<iterator, bool> insert(value_type&& obj);
+    iterator insert(const_iterator hint, const value_type& obj);
+    iterator insert(const_iterator hint, value_type&& obj);
+    template <class InputIterator>
+        void insert(InputIterator first, InputIterator last);
+    void insert(initializer_list<value_type>);
+
     node_type extract(const_iterator position);                       // C++17
     node_type extract(const key_type& x);                             // C++17
     insert_return_type insert(node_type&& nh);                        // C++17
     iterator           insert(const_iterator hint, node_type&& nh);   // C++17
 
-    iterator erase(const_iterator position); 
-    iterator erase(iterator position);  // C++14 
-    size_type erase(const key_type& k); 
-    iterator erase(const_iterator first, const_iterator last); 
-    void clear() noexcept; 
- 
+    iterator erase(const_iterator position);
+    iterator erase(iterator position);  // C++14
+    size_type erase(const key_type& k);
+    iterator erase(const_iterator first, const_iterator last);
+    void clear() noexcept;
+
     template<class H2, class P2>
       void merge(unordered_set<Key, H2, P2, Allocator>& source);         // C++17
     template<class H2, class P2>
@@ -135,174 +135,174 @@ public:
     template<class H2, class P2>
       void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);   // C++17
 
-    void swap(unordered_set&) 
-       noexcept(allocator_traits<Allocator>::is_always_equal::value && 
-                 noexcept(swap(declval<hasher&>(), declval<hasher&>())) && 
-                 noexcept(swap(declval<key_equal&>(), declval<key_equal&>()))); // C++17 
- 
-    hasher hash_function() const; 
-    key_equal key_eq() const; 
- 
-    iterator       find(const key_type& k); 
-    const_iterator find(const key_type& k) const; 
-    template<typename K> 
-        iterator find(const K& x);              // C++20 
-    template<typename K> 
-        const_iterator find(const K& x) const;  // C++20 
-    size_type count(const key_type& k) const; 
-    template<typename K> 
-        size_type count(const K& k) const; // C++20 
-    bool contains(const key_type& k) const; // C++20 
-    template<typename K> 
-        bool contains(const K& k) const; // C++20 
-    pair<iterator, iterator>             equal_range(const key_type& k); 
-    pair<const_iterator, const_iterator> equal_range(const key_type& k) const; 
-    template<typename K> 
-        pair<iterator, iterator>             equal_range(const K& k); // C++20 
-    template<typename K> 
-        pair<const_iterator, const_iterator> equal_range(const K& k) const; // C++20 
- 
-    size_type bucket_count() const noexcept; 
-    size_type max_bucket_count() const noexcept; 
- 
-    size_type bucket_size(size_type n) const; 
-    size_type bucket(const key_type& k) const; 
- 
-    local_iterator       begin(size_type n); 
-    local_iterator       end(size_type n); 
-    const_local_iterator begin(size_type n) const; 
-    const_local_iterator end(size_type n) const; 
-    const_local_iterator cbegin(size_type n) const; 
-    const_local_iterator cend(size_type n) const; 
- 
-    float load_factor() const noexcept; 
-    float max_load_factor() const noexcept; 
-    void max_load_factor(float z); 
-    void rehash(size_type n); 
-    void reserve(size_type n); 
-}; 
- 
-template <class Value, class Hash, class Pred, class Alloc> 
-    void swap(unordered_set<Value, Hash, Pred, Alloc>& x, 
-              unordered_set<Value, Hash, Pred, Alloc>& y) 
-              noexcept(noexcept(x.swap(y))); 
- 
-template <class Value, class Hash, class Pred, class Alloc> 
-    bool 
-    operator==(const unordered_set<Value, Hash, Pred, Alloc>& x, 
-               const unordered_set<Value, Hash, Pred, Alloc>& y); 
- 
-template <class Value, class Hash, class Pred, class Alloc> 
-    bool 
-    operator!=(const unordered_set<Value, Hash, Pred, Alloc>& x, 
-               const unordered_set<Value, Hash, Pred, Alloc>& y); 
- 
-template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, 
-          class Alloc = allocator<Value>> 
-class unordered_multiset 
-{ 
-public: 
-    // types 
-    typedef Value                                                      key_type; 
-    typedef key_type                                                   value_type; 
-    typedef Hash                                                       hasher; 
-    typedef Pred                                                       key_equal; 
-    typedef Alloc                                                      allocator_type; 
-    typedef value_type&                                                reference; 
-    typedef const value_type&                                          const_reference; 
-    typedef typename allocator_traits<allocator_type>::pointer         pointer; 
-    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer; 
-    typedef typename allocator_traits<allocator_type>::size_type       size_type; 
-    typedef typename allocator_traits<allocator_type>::difference_type difference_type; 
- 
-    typedef /unspecified/ iterator; 
-    typedef /unspecified/ const_iterator; 
-    typedef /unspecified/ local_iterator; 
-    typedef /unspecified/ const_local_iterator; 
- 
+    void swap(unordered_set&)
+       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+                 noexcept(swap(declval<hasher&>(), declval<hasher&>())) &&
+                 noexcept(swap(declval<key_equal&>(), declval<key_equal&>()))); // C++17
+
+    hasher hash_function() const;
+    key_equal key_eq() const;
+
+    iterator       find(const key_type& k);
+    const_iterator find(const key_type& k) const;
+    template<typename K>
+        iterator find(const K& x);              // C++20
+    template<typename K>
+        const_iterator find(const K& x) const;  // C++20
+    size_type count(const key_type& k) const;
+    template<typename K>
+        size_type count(const K& k) const; // C++20
+    bool contains(const key_type& k) const; // C++20
+    template<typename K>
+        bool contains(const K& k) const; // C++20
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+    template<typename K>
+        pair<iterator, iterator>             equal_range(const K& k); // C++20
+    template<typename K>
+        pair<const_iterator, const_iterator> equal_range(const K& k) const; // C++20
+
+    size_type bucket_count() const noexcept;
+    size_type max_bucket_count() const noexcept;
+
+    size_type bucket_size(size_type n) const;
+    size_type bucket(const key_type& k) const;
+
+    local_iterator       begin(size_type n);
+    local_iterator       end(size_type n);
+    const_local_iterator begin(size_type n) const;
+    const_local_iterator end(size_type n) const;
+    const_local_iterator cbegin(size_type n) const;
+    const_local_iterator cend(size_type n) const;
+
+    float load_factor() const noexcept;
+    float max_load_factor() const noexcept;
+    void max_load_factor(float z);
+    void rehash(size_type n);
+    void reserve(size_type n);
+};
+
+template <class Value, class Hash, class Pred, class Alloc>
+    void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
+              unordered_set<Value, Hash, Pred, Alloc>& y)
+              noexcept(noexcept(x.swap(y)));
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator==(const unordered_set<Value, Hash, Pred, Alloc>& x,
+               const unordered_set<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator!=(const unordered_set<Value, Hash, Pred, Alloc>& x,
+               const unordered_set<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+          class Alloc = allocator<Value>>
+class unordered_multiset
+{
+public:
+    // types
+    typedef Value                                                      key_type;
+    typedef key_type                                                   value_type;
+    typedef Hash                                                       hasher;
+    typedef Pred                                                       key_equal;
+    typedef Alloc                                                      allocator_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    typedef typename allocator_traits<allocator_type>::pointer         pointer;
+    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
+    typedef typename allocator_traits<allocator_type>::size_type       size_type;
+    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+
+    typedef /unspecified/ iterator;
+    typedef /unspecified/ const_iterator;
+    typedef /unspecified/ local_iterator;
+    typedef /unspecified/ const_local_iterator;
+
     typedef unspecified node_type unspecified;   // C++17
 
-    unordered_multiset() 
-        noexcept( 
-            is_nothrow_default_constructible<hasher>::value && 
-            is_nothrow_default_constructible<key_equal>::value && 
-            is_nothrow_default_constructible<allocator_type>::value); 
-    explicit unordered_multiset(size_type n, const hasher& hf = hasher(), 
-                           const key_equal& eql = key_equal(), 
-                           const allocator_type& a = allocator_type()); 
-    template <class InputIterator> 
-        unordered_multiset(InputIterator f, InputIterator l, 
-                      size_type n = 0, const hasher& hf = hasher(), 
-                      const key_equal& eql = key_equal(), 
-                      const allocator_type& a = allocator_type()); 
-    explicit unordered_multiset(const allocator_type&); 
-    unordered_multiset(const unordered_multiset&); 
-    unordered_multiset(const unordered_multiset&, const Allocator&); 
-    unordered_multiset(unordered_multiset&&) 
-        noexcept( 
-            is_nothrow_move_constructible<hasher>::value && 
-            is_nothrow_move_constructible<key_equal>::value && 
-            is_nothrow_move_constructible<allocator_type>::value); 
-    unordered_multiset(unordered_multiset&&, const Allocator&); 
-    unordered_multiset(initializer_list<value_type>, size_type n = /see below/, 
-                  const hasher& hf = hasher(), const key_equal& eql = key_equal(), 
-                  const allocator_type& a = allocator_type()); 
-    unordered_multiset(size_type n, const allocator_type& a); // C++14 
-    unordered_multiset(size_type n, const hasher& hf, const allocator_type& a); // C++14 
-    template <class InputIterator> 
-      unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14 
-    template <class InputIterator> 
-      unordered_multiset(InputIterator f, InputIterator l, size_type n, 
-                         const hasher& hf, const allocator_type& a); // C++14 
-    unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14 
+    unordered_multiset()
+        noexcept(
+            is_nothrow_default_constructible<hasher>::value &&
+            is_nothrow_default_constructible<key_equal>::value &&
+            is_nothrow_default_constructible<allocator_type>::value);
+    explicit unordered_multiset(size_type n, const hasher& hf = hasher(),
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& a = allocator_type());
+    template <class InputIterator>
+        unordered_multiset(InputIterator f, InputIterator l,
+                      size_type n = 0, const hasher& hf = hasher(),
+                      const key_equal& eql = key_equal(),
+                      const allocator_type& a = allocator_type());
+    explicit unordered_multiset(const allocator_type&);
+    unordered_multiset(const unordered_multiset&);
+    unordered_multiset(const unordered_multiset&, const Allocator&);
+    unordered_multiset(unordered_multiset&&)
+        noexcept(
+            is_nothrow_move_constructible<hasher>::value &&
+            is_nothrow_move_constructible<key_equal>::value &&
+            is_nothrow_move_constructible<allocator_type>::value);
+    unordered_multiset(unordered_multiset&&, const Allocator&);
+    unordered_multiset(initializer_list<value_type>, size_type n = /see below/,
+                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+                  const allocator_type& a = allocator_type());
+    unordered_multiset(size_type n, const allocator_type& a); // C++14
+    unordered_multiset(size_type n, const hasher& hf, const allocator_type& a); // C++14
+    template <class InputIterator>
+      unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14
+    template <class InputIterator>
+      unordered_multiset(InputIterator f, InputIterator l, size_type n,
+                         const hasher& hf, const allocator_type& a); // C++14
+    unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
     unordered_multiset(initializer_list<value_type> il, size_type n,
-                       const hasher& hf,  const allocator_type& a); // C++14 
-    ~unordered_multiset(); 
-    unordered_multiset& operator=(const unordered_multiset&); 
-    unordered_multiset& operator=(unordered_multiset&&) 
-        noexcept( 
-            allocator_type::propagate_on_container_move_assignment::value && 
-            is_nothrow_move_assignable<allocator_type>::value && 
-            is_nothrow_move_assignable<hasher>::value && 
-            is_nothrow_move_assignable<key_equal>::value); 
-    unordered_multiset& operator=(initializer_list<value_type>); 
- 
-    allocator_type get_allocator() const noexcept; 
- 
-    bool      empty() const noexcept; 
-    size_type size() const noexcept; 
-    size_type max_size() const noexcept; 
- 
-    iterator       begin() noexcept; 
-    iterator       end() noexcept; 
-    const_iterator begin()  const noexcept; 
-    const_iterator end()    const noexcept; 
-    const_iterator cbegin() const noexcept; 
-    const_iterator cend()   const noexcept; 
- 
-    template <class... Args> 
-        iterator emplace(Args&&... args); 
-    template <class... Args> 
-        iterator emplace_hint(const_iterator position, Args&&... args); 
-    iterator insert(const value_type& obj); 
-    iterator insert(value_type&& obj); 
-    iterator insert(const_iterator hint, const value_type& obj); 
-    iterator insert(const_iterator hint, value_type&& obj); 
-    template <class InputIterator> 
-        void insert(InputIterator first, InputIterator last); 
-    void insert(initializer_list<value_type>); 
- 
+                       const hasher& hf,  const allocator_type& a); // C++14
+    ~unordered_multiset();
+    unordered_multiset& operator=(const unordered_multiset&);
+    unordered_multiset& operator=(unordered_multiset&&)
+        noexcept(
+            allocator_type::propagate_on_container_move_assignment::value &&
+            is_nothrow_move_assignable<allocator_type>::value &&
+            is_nothrow_move_assignable<hasher>::value &&
+            is_nothrow_move_assignable<key_equal>::value);
+    unordered_multiset& operator=(initializer_list<value_type>);
+
+    allocator_type get_allocator() const noexcept;
+
+    bool      empty() const noexcept;
+    size_type size() const noexcept;
+    size_type max_size() const noexcept;
+
+    iterator       begin() noexcept;
+    iterator       end() noexcept;
+    const_iterator begin()  const noexcept;
+    const_iterator end()    const noexcept;
+    const_iterator cbegin() const noexcept;
+    const_iterator cend()   const noexcept;
+
+    template <class... Args>
+        iterator emplace(Args&&... args);
+    template <class... Args>
+        iterator emplace_hint(const_iterator position, Args&&... args);
+    iterator insert(const value_type& obj);
+    iterator insert(value_type&& obj);
+    iterator insert(const_iterator hint, const value_type& obj);
+    iterator insert(const_iterator hint, value_type&& obj);
+    template <class InputIterator>
+        void insert(InputIterator first, InputIterator last);
+    void insert(initializer_list<value_type>);
+
     node_type extract(const_iterator position);             // C++17
     node_type extract(const key_type& x);                   // C++17
     iterator insert(node_type&& nh);                        // C++17
     iterator insert(const_iterator hint, node_type&& nh);   // C++17
 
-    iterator erase(const_iterator position); 
-    iterator erase(iterator position);  // C++14 
-    size_type erase(const key_type& k); 
-    iterator erase(const_iterator first, const_iterator last); 
-    void clear() noexcept; 
- 
+    iterator erase(const_iterator position);
+    iterator erase(iterator position);  // C++14
+    size_type erase(const key_type& k);
+    iterator erase(const_iterator first, const_iterator last);
+    void clear() noexcept;
+
     template<class H2, class P2>
       void merge(unordered_multiset<Key, H2, P2, Allocator>& source);    // C++17
     template<class H2, class P2>
@@ -312,132 +312,132 @@ public:
     template<class H2, class P2>
       void merge(unordered_set<Key, H2, P2, Allocator>&& source);        // C++17
 
-    void swap(unordered_multiset&) 
-       noexcept(allocator_traits<Allocator>::is_always_equal::value && 
-                 noexcept(swap(declval<hasher&>(), declval<hasher&>())) && 
-                 noexcept(swap(declval<key_equal&>(), declval<key_equal&>()))); // C++17 
- 
-    hasher hash_function() const; 
-    key_equal key_eq() const; 
- 
-    iterator       find(const key_type& k); 
-    const_iterator find(const key_type& k) const; 
-    template<typename K> 
-        iterator find(const K& x);              // C++20 
-    template<typename K> 
-        const_iterator find(const K& x) const;  // C++20 
-    size_type count(const key_type& k) const; 
-    template<typename K> 
-        size_type count(const K& k) const; // C++20 
-    bool contains(const key_type& k) const; // C++20 
-    template<typename K> 
-        bool contains(const K& k) const; // C++20 
-    pair<iterator, iterator>             equal_range(const key_type& k); 
-    pair<const_iterator, const_iterator> equal_range(const key_type& k) const; 
-    template<typename K> 
-        pair<iterator, iterator>             equal_range(const K& k); // C++20 
-    template<typename K> 
-        pair<const_iterator, const_iterator> equal_range(const K& k) const; // C++20 
- 
-    size_type bucket_count() const noexcept; 
-    size_type max_bucket_count() const noexcept; 
- 
-    size_type bucket_size(size_type n) const; 
-    size_type bucket(const key_type& k) const; 
- 
-    local_iterator       begin(size_type n); 
-    local_iterator       end(size_type n); 
-    const_local_iterator begin(size_type n) const; 
-    const_local_iterator end(size_type n) const; 
-    const_local_iterator cbegin(size_type n) const; 
-    const_local_iterator cend(size_type n) const; 
- 
-    float load_factor() const noexcept; 
-    float max_load_factor() const noexcept; 
-    void max_load_factor(float z); 
-    void rehash(size_type n); 
-    void reserve(size_type n); 
-}; 
- 
-template <class Value, class Hash, class Pred, class Alloc> 
-    void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x, 
-              unordered_multiset<Value, Hash, Pred, Alloc>& y) 
-              noexcept(noexcept(x.swap(y))); 
- 
+    void swap(unordered_multiset&)
+       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+                 noexcept(swap(declval<hasher&>(), declval<hasher&>())) &&
+                 noexcept(swap(declval<key_equal&>(), declval<key_equal&>()))); // C++17
+
+    hasher hash_function() const;
+    key_equal key_eq() const;
+
+    iterator       find(const key_type& k);
+    const_iterator find(const key_type& k) const;
+    template<typename K>
+        iterator find(const K& x);              // C++20
+    template<typename K>
+        const_iterator find(const K& x) const;  // C++20
+    size_type count(const key_type& k) const;
+    template<typename K>
+        size_type count(const K& k) const; // C++20
+    bool contains(const key_type& k) const; // C++20
+    template<typename K>
+        bool contains(const K& k) const; // C++20
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+    template<typename K>
+        pair<iterator, iterator>             equal_range(const K& k); // C++20
+    template<typename K>
+        pair<const_iterator, const_iterator> equal_range(const K& k) const; // C++20
+
+    size_type bucket_count() const noexcept;
+    size_type max_bucket_count() const noexcept;
+
+    size_type bucket_size(size_type n) const;
+    size_type bucket(const key_type& k) const;
+
+    local_iterator       begin(size_type n);
+    local_iterator       end(size_type n);
+    const_local_iterator begin(size_type n) const;
+    const_local_iterator end(size_type n) const;
+    const_local_iterator cbegin(size_type n) const;
+    const_local_iterator cend(size_type n) const;
+
+    float load_factor() const noexcept;
+    float max_load_factor() const noexcept;
+    void max_load_factor(float z);
+    void rehash(size_type n);
+    void reserve(size_type n);
+};
+
+template <class Value, class Hash, class Pred, class Alloc>
+    void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
+              unordered_multiset<Value, Hash, Pred, Alloc>& y)
+              noexcept(noexcept(x.swap(y)));
+
 template <class K, class T, class H, class P, class A, class Predicate>
-    typename unordered_set<K, T, H, P, A>::size_type 
-    erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred);       // C++20 
+    typename unordered_set<K, T, H, P, A>::size_type
+    erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred);       // C++20
 
 template <class K, class T, class H, class P, class A, class Predicate>
-    typename unordered_multiset<K, T, H, P, A>::size_type 
-    erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred);  // C++20 
-
-
-template <class Value, class Hash, class Pred, class Alloc> 
-    bool 
-    operator==(const unordered_multiset<Value, Hash, Pred, Alloc>& x, 
-               const unordered_multiset<Value, Hash, Pred, Alloc>& y); 
- 
-template <class Value, class Hash, class Pred, class Alloc> 
-    bool 
-    operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x, 
-               const unordered_multiset<Value, Hash, Pred, Alloc>& y); 
-}  // std 
- 
-*/ 
- 
-#include <__config> 
-#include <__debug> 
-#include <__functional/is_transparent.h> 
-#include <__hash_table> 
+    typename unordered_multiset<K, T, H, P, A>::size_type
+    erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred);  // C++20
+
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator==(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
+               const unordered_multiset<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
+               const unordered_multiset<Value, Hash, Pred, Alloc>& y);
+}  // std
+
+*/
+
+#include <__config>
+#include <__debug>
+#include <__functional/is_transparent.h>
+#include <__hash_table>
 #include <__node_handle>
-#include <__utility/forward.h> 
-#include <compare> 
-#include <functional> 
-#include <iterator> // __libcpp_erase_if_container 
+#include <__utility/forward.h>
+#include <compare>
+#include <functional>
+#include <iterator> // __libcpp_erase_if_container
 #include <version>
- 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
-#pragma GCC system_header 
-#endif 
- 
-_LIBCPP_BEGIN_NAMESPACE_STD 
- 
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 class unordered_multiset;
 
-template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, 
-          class _Alloc = allocator<_Value> > 
-class _LIBCPP_TEMPLATE_VIS unordered_set 
-{ 
-public: 
-    // types 
-    typedef _Value                                                     key_type; 
-    typedef key_type                                                   value_type; 
-    typedef __identity_t<_Hash>                                        hasher; 
-    typedef __identity_t<_Pred>                                        key_equal; 
-    typedef __identity_t<_Alloc>                                       allocator_type; 
-    typedef value_type&                                                reference; 
-    typedef const value_type&                                          const_reference; 
-    static_assert((is_same<value_type, typename allocator_type::value_type>::value), 
-                  "Invalid allocator::value_type"); 
- 
-private: 
-    typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table; 
- 
-    __table __table_; 
- 
-public: 
-    typedef typename __table::pointer         pointer; 
-    typedef typename __table::const_pointer   const_pointer; 
-    typedef typename __table::size_type       size_type; 
-    typedef typename __table::difference_type difference_type; 
- 
-    typedef typename __table::const_iterator       iterator; 
-    typedef typename __table::const_iterator       const_iterator; 
-    typedef typename __table::const_local_iterator local_iterator; 
-    typedef typename __table::const_local_iterator const_local_iterator; 
- 
+template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
+          class _Alloc = allocator<_Value> >
+class _LIBCPP_TEMPLATE_VIS unordered_set
+{
+public:
+    // types
+    typedef _Value                                                     key_type;
+    typedef key_type                                                   value_type;
+    typedef __identity_t<_Hash>                                        hasher;
+    typedef __identity_t<_Pred>                                        key_equal;
+    typedef __identity_t<_Alloc>                                       allocator_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    static_assert((is_same<value_type, typename allocator_type::value_type>::value),
+                  "Invalid allocator::value_type");
+
+private:
+    typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
+
+    __table __table_;
+
+public:
+    typedef typename __table::pointer         pointer;
+    typedef typename __table::const_pointer   const_pointer;
+    typedef typename __table::size_type       size_type;
+    typedef typename __table::difference_type difference_type;
+
+    typedef typename __table::const_iterator       iterator;
+    typedef typename __table::const_iterator       const_iterator;
+    typedef typename __table::const_local_iterator local_iterator;
+    typedef typename __table::const_local_iterator const_local_iterator;
+
 #if _LIBCPP_STD_VER > 14
     typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
     typedef __insert_return_type<iterator, node_type> insert_return_type;
@@ -448,190 +448,190 @@ public:
     template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
         friend class _LIBCPP_TEMPLATE_VIS unordered_multiset;
 
-    _LIBCPP_INLINE_VISIBILITY 
-    unordered_set() 
-        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) 
-        { 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-            __get_db()->__insert_c(this); 
-#endif 
-        } 
-    explicit unordered_set(size_type __n, const hasher& __hf = hasher(), 
-                           const key_equal& __eql = key_equal()); 
-#if _LIBCPP_STD_VER > 11 
-    inline _LIBCPP_INLINE_VISIBILITY 
-    unordered_set(size_type __n, const allocator_type& __a) 
-        : unordered_set(__n, hasher(), key_equal(), __a) {} 
-    inline _LIBCPP_INLINE_VISIBILITY 
-    unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a) 
-        : unordered_set(__n, __hf, key_equal(), __a) {} 
-#endif 
-    unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql, 
-                  const allocator_type& __a); 
-    template <class _InputIterator> 
-        unordered_set(_InputIterator __first, _InputIterator __last); 
-    template <class _InputIterator> 
-        unordered_set(_InputIterator __first, _InputIterator __last, 
-                      size_type __n, const hasher& __hf = hasher(), 
-                      const key_equal& __eql = key_equal()); 
-    template <class _InputIterator> 
-        unordered_set(_InputIterator __first, _InputIterator __last, 
-                      size_type __n, const hasher& __hf, const key_equal& __eql, 
-                      const allocator_type& __a); 
-#if _LIBCPP_STD_VER > 11 
-    template <class _InputIterator> 
-    inline _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_set()
+        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
+        {
+#if _LIBCPP_DEBUG_LEVEL == 2
+            __get_db()->__insert_c(this);
+#endif
+        }
+    explicit unordered_set(size_type __n, const hasher& __hf = hasher(),
+                           const key_equal& __eql = key_equal());
+#if _LIBCPP_STD_VER > 11
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_set(size_type __n, const allocator_type& __a)
+        : unordered_set(__n, hasher(), key_equal(), __a) {}
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a)
+        : unordered_set(__n, __hf, key_equal(), __a) {}
+#endif
+    unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql,
+                  const allocator_type& __a);
+    template <class _InputIterator>
+        unordered_set(_InputIterator __first, _InputIterator __last);
+    template <class _InputIterator>
         unordered_set(_InputIterator __first, _InputIterator __last,
-                    size_type __n, const allocator_type& __a) 
-            : unordered_set(__first, __last, __n, hasher(), key_equal(), __a) {} 
-    template <class _InputIterator> 
+                      size_type __n, const hasher& __hf = hasher(),
+                      const key_equal& __eql = key_equal());
+    template <class _InputIterator>
         unordered_set(_InputIterator __first, _InputIterator __last,
-                      size_type __n, const hasher& __hf, const allocator_type& __a) 
-            : unordered_set(__first, __last, __n, __hf, key_equal(), __a) {} 
-#endif 
-    _LIBCPP_INLINE_VISIBILITY 
-    explicit unordered_set(const allocator_type& __a); 
-    unordered_set(const unordered_set& __u); 
-    unordered_set(const unordered_set& __u, const allocator_type& __a); 
-#ifndef _LIBCPP_CXX03_LANG 
-    _LIBCPP_INLINE_VISIBILITY 
-    unordered_set(unordered_set&& __u) 
-        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value); 
-    unordered_set(unordered_set&& __u, const allocator_type& __a); 
-    unordered_set(initializer_list<value_type> __il); 
-    unordered_set(initializer_list<value_type> __il, size_type __n, 
-                  const hasher& __hf = hasher(), 
-                  const key_equal& __eql = key_equal()); 
-    unordered_set(initializer_list<value_type> __il, size_type __n, 
-                  const hasher& __hf, const key_equal& __eql, 
-                  const allocator_type& __a); 
-#if _LIBCPP_STD_VER > 11 
-    inline _LIBCPP_INLINE_VISIBILITY 
-    unordered_set(initializer_list<value_type> __il, size_type __n, 
-                                                      const allocator_type& __a) 
-        : unordered_set(__il, __n, hasher(), key_equal(), __a) {} 
-    inline _LIBCPP_INLINE_VISIBILITY 
+                      size_type __n, const hasher& __hf, const key_equal& __eql,
+                      const allocator_type& __a);
+#if _LIBCPP_STD_VER > 11
+    template <class _InputIterator>
+    inline _LIBCPP_INLINE_VISIBILITY
+        unordered_set(_InputIterator __first, _InputIterator __last,
+                    size_type __n, const allocator_type& __a)
+            : unordered_set(__first, __last, __n, hasher(), key_equal(), __a) {}
+    template <class _InputIterator>
+        unordered_set(_InputIterator __first, _InputIterator __last,
+                      size_type __n, const hasher& __hf, const allocator_type& __a)
+            : unordered_set(__first, __last, __n, __hf, key_equal(), __a) {}
+#endif
+    _LIBCPP_INLINE_VISIBILITY
+    explicit unordered_set(const allocator_type& __a);
+    unordered_set(const unordered_set& __u);
+    unordered_set(const unordered_set& __u, const allocator_type& __a);
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_set(unordered_set&& __u)
+        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+    unordered_set(unordered_set&& __u, const allocator_type& __a);
+    unordered_set(initializer_list<value_type> __il);
+    unordered_set(initializer_list<value_type> __il, size_type __n,
+                  const hasher& __hf = hasher(),
+                  const key_equal& __eql = key_equal());
     unordered_set(initializer_list<value_type> __il, size_type __n,
-                                  const hasher& __hf, const allocator_type& __a) 
-        : unordered_set(__il, __n, __hf, key_equal(), __a) {} 
-#endif 
-#endif // _LIBCPP_CXX03_LANG 
-    _LIBCPP_INLINE_VISIBILITY 
-    ~unordered_set() { 
-        static_assert(sizeof(__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), ""); 
-    } 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    unordered_set& operator=(const unordered_set& __u) 
-    { 
-        __table_ = __u.__table_; 
-        return *this; 
-    } 
-#ifndef _LIBCPP_CXX03_LANG 
-    _LIBCPP_INLINE_VISIBILITY 
-    unordered_set& operator=(unordered_set&& __u) 
-        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value); 
-    _LIBCPP_INLINE_VISIBILITY 
-    unordered_set& operator=(initializer_list<value_type> __il); 
-#endif // _LIBCPP_CXX03_LANG 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    allocator_type get_allocator() const _NOEXCEPT 
-        {return allocator_type(__table_.__node_alloc());} 
- 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 
-    bool      empty() const _NOEXCEPT {return __table_.size() == 0;} 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type size() const _NOEXCEPT  {return __table_.size();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type max_size() const _NOEXCEPT {return __table_.max_size();} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator       begin() _NOEXCEPT        {return __table_.begin();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator       end() _NOEXCEPT          {return __table_.end();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator begin()  const _NOEXCEPT {return __table_.begin();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator end()    const _NOEXCEPT {return __table_.end();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator cend()   const _NOEXCEPT {return __table_.end();} 
- 
-#ifndef _LIBCPP_CXX03_LANG 
-    template <class... _Args> 
-        _LIBCPP_INLINE_VISIBILITY 
-        pair<iterator, bool> emplace(_Args&&... __args) 
-            {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);} 
-    template <class... _Args> 
-        _LIBCPP_INLINE_VISIBILITY 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-        iterator emplace_hint(const_iterator __p, _Args&&... __args) 
-        { 
-            _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
-                "unordered_set::emplace_hint(const_iterator, args...) called with an iterator not" 
-                " referring to this unordered_set"); 
-            return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first; 
-        } 
-#else 
-        iterator emplace_hint(const_iterator, _Args&&... __args) 
-            {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;} 
-#endif 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    pair<iterator, bool> insert(value_type&& __x) 
-        {return __table_.__insert_unique(_VSTD::move(__x));} 
-    _LIBCPP_INLINE_VISIBILITY 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    iterator insert(const_iterator __p, value_type&& __x) 
-        { 
-            _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
-                "unordered_set::insert(const_iterator, value_type&&) called with an iterator not" 
-                " referring to this unordered_set"); 
-            return insert(_VSTD::move(__x)).first; 
-        } 
-#else 
-    iterator insert(const_iterator, value_type&& __x) 
-        {return insert(_VSTD::move(__x)).first;} 
-#endif 
-    _LIBCPP_INLINE_VISIBILITY 
-    void insert(initializer_list<value_type> __il) 
-        {insert(__il.begin(), __il.end());} 
-#endif // _LIBCPP_CXX03_LANG 
-    _LIBCPP_INLINE_VISIBILITY 
-    pair<iterator, bool> insert(const value_type& __x) 
-        {return __table_.__insert_unique(__x);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    iterator insert(const_iterator __p, const value_type& __x) 
-        { 
-            _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
-                "unordered_set::insert(const_iterator, const value_type&) called with an iterator not" 
-                " referring to this unordered_set"); 
-            return insert(__x).first; 
-        } 
-#else 
-    iterator insert(const_iterator, const value_type& __x) 
-        {return insert(__x).first;} 
-#endif 
-    template <class _InputIterator> 
-        _LIBCPP_INLINE_VISIBILITY 
-        void insert(_InputIterator __first, _InputIterator __last); 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator erase(const_iterator __p) {return __table_.erase(__p);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator erase(const_iterator __first, const_iterator __last) 
-        {return __table_.erase(__first, __last);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    void clear() _NOEXCEPT {__table_.clear();} 
- 
+                  const hasher& __hf, const key_equal& __eql,
+                  const allocator_type& __a);
+#if _LIBCPP_STD_VER > 11
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_set(initializer_list<value_type> __il, size_type __n,
+                                                      const allocator_type& __a)
+        : unordered_set(__il, __n, hasher(), key_equal(), __a) {}
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_set(initializer_list<value_type> __il, size_type __n,
+                                  const hasher& __hf, const allocator_type& __a)
+        : unordered_set(__il, __n, __hf, key_equal(), __a) {}
+#endif
+#endif // _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    ~unordered_set() {
+        static_assert(sizeof(__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_set& operator=(const unordered_set& __u)
+    {
+        __table_ = __u.__table_;
+        return *this;
+    }
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_set& operator=(unordered_set&& __u)
+        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_set& operator=(initializer_list<value_type> __il);
+#endif // _LIBCPP_CXX03_LANG
+
+    _LIBCPP_INLINE_VISIBILITY
+    allocator_type get_allocator() const _NOEXCEPT
+        {return allocator_type(__table_.__node_alloc());}
+
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
+    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
+    _LIBCPP_INLINE_VISIBILITY
+    size_type size() const _NOEXCEPT  {return __table_.size();}
+    _LIBCPP_INLINE_VISIBILITY
+    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator       begin() _NOEXCEPT        {return __table_.begin();}
+    _LIBCPP_INLINE_VISIBILITY
+    iterator       end() _NOEXCEPT          {return __table_.end();}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator end()    const _NOEXCEPT {return __table_.end();}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
+
+#ifndef _LIBCPP_CXX03_LANG
+    template <class... _Args>
+        _LIBCPP_INLINE_VISIBILITY
+        pair<iterator, bool> emplace(_Args&&... __args)
+            {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
+    template <class... _Args>
+        _LIBCPP_INLINE_VISIBILITY
+#if _LIBCPP_DEBUG_LEVEL == 2
+        iterator emplace_hint(const_iterator __p, _Args&&... __args)
+        {
+            _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+                "unordered_set::emplace_hint(const_iterator, args...) called with an iterator not"
+                " referring to this unordered_set");
+            return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;
+        }
+#else
+        iterator emplace_hint(const_iterator, _Args&&... __args)
+            {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;}
+#endif
+
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> insert(value_type&& __x)
+        {return __table_.__insert_unique(_VSTD::move(__x));}
+    _LIBCPP_INLINE_VISIBILITY
+#if _LIBCPP_DEBUG_LEVEL == 2
+    iterator insert(const_iterator __p, value_type&& __x)
+        {
+            _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+                "unordered_set::insert(const_iterator, value_type&&) called with an iterator not"
+                " referring to this unordered_set");
+            return insert(_VSTD::move(__x)).first;
+        }
+#else
+    iterator insert(const_iterator, value_type&& __x)
+        {return insert(_VSTD::move(__x)).first;}
+#endif
+    _LIBCPP_INLINE_VISIBILITY
+    void insert(initializer_list<value_type> __il)
+        {insert(__il.begin(), __il.end());}
+#endif // _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, bool> insert(const value_type& __x)
+        {return __table_.__insert_unique(__x);}
+
+    _LIBCPP_INLINE_VISIBILITY
+#if _LIBCPP_DEBUG_LEVEL == 2
+    iterator insert(const_iterator __p, const value_type& __x)
+        {
+            _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
+                "unordered_set::insert(const_iterator, const value_type&) called with an iterator not"
+                " referring to this unordered_set");
+            return insert(__x).first;
+        }
+#else
+    iterator insert(const_iterator, const value_type& __x)
+        {return insert(__x).first;}
+#endif
+    template <class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY
+        void insert(_InputIterator __first, _InputIterator __last);
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator erase(const_iterator __p) {return __table_.erase(__p);}
+    _LIBCPP_INLINE_VISIBILITY
+    size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
+    _LIBCPP_INLINE_VISIBILITY
+    iterator erase(const_iterator __first, const_iterator __last)
+        {return __table_.erase(__first, __last);}
+    _LIBCPP_INLINE_VISIBILITY
+    void clear() _NOEXCEPT {__table_.clear();}
+
 #if _LIBCPP_STD_VER > 14
-    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_INLINE_VISIBILITY
     insert_return_type insert(node_type&& __nh)
     {
         _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
@@ -693,448 +693,448 @@ public:
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_set& __u) 
-        _NOEXCEPT_(__is_nothrow_swappable<__table>::value) 
-        {__table_.swap(__u.__table_);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    hasher hash_function() const {return __table_.hash_function();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    key_equal key_eq() const {return __table_.key_eq();} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator       find(const key_type& __k)       {return __table_.find(__k);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator find(const key_type& __k) const {return __table_.find(__k);} 
-#if _LIBCPP_STD_VER > 17 
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator       find(const _K2& __k)            {return __table_.find(__k);} 
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator find(const _K2& __k) const      {return __table_.find(__k);} 
-#endif // _LIBCPP_STD_VER > 17 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type count(const key_type& __k) const {return __table_.__count_unique(__k);} 
-#if _LIBCPP_STD_VER > 17 
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type count(const _K2& __k) const      {return __table_.__count_unique(__k);} 
-#endif // _LIBCPP_STD_VER > 17 
- 
-#if _LIBCPP_STD_VER > 17 
-    _LIBCPP_INLINE_VISIBILITY 
-    bool contains(const key_type& __k) const {return find(__k) != end();} 
- 
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    bool contains(const _K2& __k) const      {return find(__k) != end();} 
-#endif // _LIBCPP_STD_VER > 17 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    pair<iterator, iterator>             equal_range(const key_type& __k) 
-        {return __table_.__equal_range_unique(__k);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    pair<const_iterator, const_iterator> equal_range(const key_type& __k) const 
-        {return __table_.__equal_range_unique(__k);} 
-#if _LIBCPP_STD_VER > 17 
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    pair<iterator, iterator>             equal_range(const _K2& __k) 
-        {return __table_.__equal_range_unique(__k);} 
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    pair<const_iterator, const_iterator> equal_range(const _K2& __k) const 
-        {return __table_.__equal_range_unique(__k);} 
-#endif // _LIBCPP_STD_VER > 17 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type bucket(const key_type& __k) const {return __table_.bucket(__k);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    local_iterator       begin(size_type __n)        {return __table_.begin(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    local_iterator       end(size_type __n)          {return __table_.end(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_local_iterator begin(size_type __n) const  {return __table_.cbegin(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_local_iterator end(size_type __n) const    {return __table_.cend(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    float load_factor() const _NOEXCEPT {return __table_.load_factor();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    void rehash(size_type __n) {__table_.rehash(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    void reserve(size_type __n) {__table_.reserve(__n);} 
- 
-#if _LIBCPP_DEBUG_LEVEL == 2 
- 
-    bool __dereferenceable(const const_iterator* __i) const 
-        {return __table_.__dereferenceable(__i);} 
-    bool __decrementable(const const_iterator* __i) const 
-        {return __table_.__decrementable(__i);} 
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const 
-        {return __table_.__addable(__i, __n);} 
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const 
-        {return __table_.__addable(__i, __n);} 
- 
-#endif // _LIBCPP_DEBUG_LEVEL == 2 
- 
-}; 
- 
-#if _LIBCPP_STD_VER >= 17 
-template<class _InputIterator, 
-         class _Hash = hash<__iter_value_type<_InputIterator>>, 
-         class _Pred = equal_to<__iter_value_type<_InputIterator>>, 
-         class _Allocator = allocator<__iter_value_type<_InputIterator>>, 
-         class = enable_if_t<!__is_allocator<_Hash>::value>, 
-         class = enable_if_t<!is_integral<_Hash>::value>, 
-         class = enable_if_t<!__is_allocator<_Pred>::value>, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_set(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0, 
-              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) 
-  -> unordered_set<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>; 
- 
-template<class _Tp, class _Hash = hash<_Tp>, 
-         class _Pred = equal_to<_Tp>, 
-         class _Allocator = allocator<_Tp>, 
-         class = enable_if_t<!__is_allocator<_Hash>::value>, 
-         class = enable_if_t<!is_integral<_Hash>::value>, 
-         class = enable_if_t<!__is_allocator<_Pred>::value>, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type = 0, 
-              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) 
-  -> unordered_set<_Tp, _Hash, _Pred, _Allocator>; 
- 
-template<class _InputIterator, class _Allocator, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_set(_InputIterator, _InputIterator, 
-              typename allocator_traits<_Allocator>::size_type, _Allocator) 
-  -> unordered_set<__iter_value_type<_InputIterator>, 
-                   hash<__iter_value_type<_InputIterator>>, 
-                   equal_to<__iter_value_type<_InputIterator>>, 
-                   _Allocator>; 
- 
-template<class _InputIterator, class _Hash, class _Allocator, 
-         class = enable_if_t<!__is_allocator<_Hash>::value>, 
-         class = enable_if_t<!is_integral<_Hash>::value>, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_set(_InputIterator, _InputIterator, 
-              typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator) 
-  -> unordered_set<__iter_value_type<_InputIterator>, _Hash, 
-                   equal_to<__iter_value_type<_InputIterator>>, 
-                   _Allocator>; 
- 
-template<class _Tp, class _Allocator, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator) 
-  -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>; 
- 
-template<class _Tp, class _Hash, class _Allocator, 
-         class = enable_if_t<!__is_allocator<_Hash>::value>, 
-         class = enable_if_t<!is_integral<_Hash>::value>, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator) 
-  -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>; 
-#endif 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n, 
-        const hasher& __hf, const key_equal& __eql) 
-    : __table_(__hf, __eql) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n, 
-        const hasher& __hf, const key_equal& __eql, const allocator_type& __a) 
-    : __table_(__hf, __eql, __a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-template <class _InputIterator> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        _InputIterator __first, _InputIterator __last) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    insert(__first, __last); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-template <class _InputIterator> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        _InputIterator __first, _InputIterator __last, size_type __n, 
-        const hasher& __hf, const key_equal& __eql) 
-    : __table_(__hf, __eql) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-    insert(__first, __last); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-template <class _InputIterator> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        _InputIterator __first, _InputIterator __last, size_type __n, 
-        const hasher& __hf, const key_equal& __eql, const allocator_type& __a) 
-    : __table_(__hf, __eql, __a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-    insert(__first, __last); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        const allocator_type& __a) 
-    : __table_(__a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        const unordered_set& __u) 
-    : __table_(__u.__table_) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__u.bucket_count()); 
-    insert(__u.begin(), __u.end()); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        const unordered_set& __u, const allocator_type& __a) 
-    : __table_(__u.__table_, __a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__u.bucket_count()); 
-    insert(__u.begin(), __u.end()); 
-} 
- 
-#ifndef _LIBCPP_CXX03_LANG 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        unordered_set&& __u) 
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value) 
-    : __table_(_VSTD::move(__u.__table_)) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-    __get_db()->swap(this, &__u); 
-#endif 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        unordered_set&& __u, const allocator_type& __a) 
-    : __table_(_VSTD::move(__u.__table_), __a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    if (__a != __u.get_allocator()) 
-    { 
-        iterator __i = __u.begin(); 
-        while (__u.size() != 0) 
-            __table_.__insert_unique(_VSTD::move(__u.__table_.remove(__i++)->__value_)); 
-    } 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    else 
-        __get_db()->swap(this, &__u); 
-#endif 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        initializer_list<value_type> __il) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    insert(__il.begin(), __il.end()); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf, 
-        const key_equal& __eql) 
-    : __table_(__hf, __eql) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-    insert(__il.begin(), __il.end()); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( 
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf, 
-        const key_equal& __eql, const allocator_type& __a) 
-    : __table_(__hf, __eql, __a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-    insert(__il.begin(), __il.end()); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline 
-unordered_set<_Value, _Hash, _Pred, _Alloc>& 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u) 
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) 
-{ 
-    __table_ = _VSTD::move(__u.__table_); 
-    return *this; 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline 
-unordered_set<_Value, _Hash, _Pred, _Alloc>& 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=( 
-        initializer_list<value_type> __il) 
-{ 
-    __table_.__assign_unique(__il.begin(), __il.end()); 
-    return *this; 
-} 
- 
-#endif // _LIBCPP_CXX03_LANG 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-template <class _InputIterator> 
-inline 
-void 
-unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, 
-                                                    _InputIterator __last) 
-{ 
-    for (; __first != __last; ++__first) 
-        __table_.__insert_unique(*__first); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline _LIBCPP_INLINE_VISIBILITY 
-void 
-swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, 
-     unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) 
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) 
-{ 
-    __x.swap(__y); 
-} 
- 
+    void swap(unordered_set& __u)
+        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
+        {__table_.swap(__u.__table_);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    hasher hash_function() const {return __table_.hash_function();}
+    _LIBCPP_INLINE_VISIBILITY
+    key_equal key_eq() const {return __table_.key_eq();}
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator       find(const key_type& __k)       {return __table_.find(__k);}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator find(const key_type& __k) const {return __table_.find(__k);}
+#if _LIBCPP_STD_VER > 17
+    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator       find(const _K2& __k)            {return __table_.find(__k);}
+    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator find(const _K2& __k) const      {return __table_.find(__k);}
+#endif // _LIBCPP_STD_VER > 17
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
+#if _LIBCPP_STD_VER > 17
+    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    size_type count(const _K2& __k) const      {return __table_.__count_unique(__k);}
+#endif // _LIBCPP_STD_VER > 17
+
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY
+    bool contains(const key_type& __k) const {return find(__k) != end();}
+
+    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    bool contains(const _K2& __k) const      {return find(__k) != end();}
+#endif // _LIBCPP_STD_VER > 17
+
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, iterator>             equal_range(const key_type& __k)
+        {return __table_.__equal_range_unique(__k);}
+    _LIBCPP_INLINE_VISIBILITY
+    pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
+        {return __table_.__equal_range_unique(__k);}
+#if _LIBCPP_STD_VER > 17
+    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, iterator>             equal_range(const _K2& __k)
+        {return __table_.__equal_range_unique(__k);}
+    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
+        {return __table_.__equal_range_unique(__k);}
+#endif // _LIBCPP_STD_VER > 17
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
+    _LIBCPP_INLINE_VISIBILITY
+    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    local_iterator       begin(size_type __n)        {return __table_.begin(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    local_iterator       end(size_type __n)          {return __table_.end(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    const_local_iterator begin(size_type __n) const  {return __table_.cbegin(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    const_local_iterator end(size_type __n) const    {return __table_.cend(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
+    _LIBCPP_INLINE_VISIBILITY
+    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
+    _LIBCPP_INLINE_VISIBILITY
+    void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
+    _LIBCPP_INLINE_VISIBILITY
+    void rehash(size_type __n) {__table_.rehash(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    void reserve(size_type __n) {__table_.reserve(__n);}
+
+#if _LIBCPP_DEBUG_LEVEL == 2
+
+    bool __dereferenceable(const const_iterator* __i) const
+        {return __table_.__dereferenceable(__i);}
+    bool __decrementable(const const_iterator* __i) const
+        {return __table_.__decrementable(__i);}
+    bool __addable(const const_iterator* __i, ptrdiff_t __n) const
+        {return __table_.__addable(__i, __n);}
+    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
+        {return __table_.__addable(__i, __n);}
+
+#endif // _LIBCPP_DEBUG_LEVEL == 2
+
+};
+
+#if _LIBCPP_STD_VER >= 17
+template<class _InputIterator,
+         class _Hash = hash<__iter_value_type<_InputIterator>>,
+         class _Pred = equal_to<__iter_value_type<_InputIterator>>,
+         class _Allocator = allocator<__iter_value_type<_InputIterator>>,
+         class = enable_if_t<!__is_allocator<_Hash>::value>,
+         class = enable_if_t<!is_integral<_Hash>::value>,
+         class = enable_if_t<!__is_allocator<_Pred>::value>,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_set<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
+
+template<class _Tp, class _Hash = hash<_Tp>,
+         class _Pred = equal_to<_Tp>,
+         class _Allocator = allocator<_Tp>,
+         class = enable_if_t<!__is_allocator<_Hash>::value>,
+         class = enable_if_t<!is_integral<_Hash>::value>,
+         class = enable_if_t<!__is_allocator<_Pred>::value>,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_set<_Tp, _Hash, _Pred, _Allocator>;
+
+template<class _InputIterator, class _Allocator,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(_InputIterator, _InputIterator,
+              typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_set<__iter_value_type<_InputIterator>,
+                   hash<__iter_value_type<_InputIterator>>,
+                   equal_to<__iter_value_type<_InputIterator>>,
+                   _Allocator>;
+
+template<class _InputIterator, class _Hash, class _Allocator,
+         class = enable_if_t<!__is_allocator<_Hash>::value>,
+         class = enable_if_t<!is_integral<_Hash>::value>,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(_InputIterator, _InputIterator,
+              typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_set<__iter_value_type<_InputIterator>, _Hash,
+                   equal_to<__iter_value_type<_InputIterator>>,
+                   _Allocator>;
+
+template<class _Tp, class _Allocator,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
+template<class _Tp, class _Hash, class _Allocator,
+         class = enable_if_t<!__is_allocator<_Hash>::value>,
+         class = enable_if_t<!is_integral<_Hash>::value>,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
+#endif
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n,
+        const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n,
+        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        _InputIterator __first, _InputIterator __last)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        const allocator_type& __a)
+    : __table_(__a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        const unordered_set& __u)
+    : __table_(__u.__table_)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__u.bucket_count());
+    insert(__u.begin(), __u.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        const unordered_set& __u, const allocator_type& __a)
+    : __table_(__u.__table_, __a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__u.bucket_count());
+    insert(__u.begin(), __u.end());
+}
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        unordered_set&& __u)
+    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
+    : __table_(_VSTD::move(__u.__table_))
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+    __get_db()->swap(this, &__u);
+#endif
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        unordered_set&& __u, const allocator_type& __a)
+    : __table_(_VSTD::move(__u.__table_), __a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    if (__a != __u.get_allocator())
+    {
+        iterator __i = __u.begin();
+        while (__u.size() != 0)
+            __table_.__insert_unique(_VSTD::move(__u.__table_.remove(__i++)->__value_));
+    }
+#if _LIBCPP_DEBUG_LEVEL == 2
+    else
+        __get_db()->swap(this, &__u);
+#endif
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        initializer_list<value_type> __il)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    insert(__il.begin(), __il.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
+        const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+    insert(__il.begin(), __il.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
+        const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+    insert(__il.begin(), __il.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline
+unordered_set<_Value, _Hash, _Pred, _Alloc>&
+unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
+    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
+{
+    __table_ = _VSTD::move(__u.__table_);
+    return *this;
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline
+unordered_set<_Value, _Hash, _Pred, _Alloc>&
+unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(
+        initializer_list<value_type> __il)
+{
+    __table_.__assign_unique(__il.begin(), __il.end());
+    return *this;
+}
+
+#endif // _LIBCPP_CXX03_LANG
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline
+void
+unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
+                                                    _InputIterator __last)
+{
+    for (; __first != __last; ++__first)
+        __table_.__insert_unique(*__first);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+     unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
+{
+    __x.swap(__y);
+}
+
 #if _LIBCPP_STD_VER > 17
-template <class _Value, class _Hash, class _Pred, class _Alloc, 
-          class _Predicate> 
+template <class _Value, class _Hash, class _Pred, class _Alloc,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-    typename unordered_set<_Value, _Hash, _Pred, _Alloc>::size_type 
-    erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c, 
-             _Predicate __pred) { 
-  return _VSTD::__libcpp_erase_if_container(__c, __pred); 
-} 
+    typename unordered_set<_Value, _Hash, _Pred, _Alloc>::size_type
+    erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c,
+             _Predicate __pred) {
+  return _VSTD::__libcpp_erase_if_container(__c, __pred);
+}
 #endif
 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-bool 
-operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, 
-           const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) 
-{ 
-    if (__x.size() != __y.size()) 
-        return false; 
-    typedef typename unordered_set<_Value, _Hash, _Pred, _Alloc>::const_iterator 
-                                                                 const_iterator; 
-    for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end(); 
-            __i != __ex; ++__i) 
-    { 
-        const_iterator __j = __y.find(*__i); 
-        if (__j == __ey || !(*__i == *__j)) 
-            return false; 
-    } 
-    return true; 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, 
-           const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) 
-{ 
-    return !(__x == __y); 
-} 
- 
-template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, 
-          class _Alloc = allocator<_Value> > 
-class _LIBCPP_TEMPLATE_VIS unordered_multiset 
-{ 
-public: 
-    // types 
-    typedef _Value                                                     key_type; 
-    typedef key_type                                                   value_type; 
-    typedef __identity_t<_Hash>                                        hasher; 
-    typedef __identity_t<_Pred>                                        key_equal; 
-    typedef __identity_t<_Alloc>                                       allocator_type; 
-    typedef value_type&                                                reference; 
-    typedef const value_type&                                          const_reference; 
-    static_assert((is_same<value_type, typename allocator_type::value_type>::value), 
-                  "Invalid allocator::value_type"); 
- 
-private: 
-    typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table; 
- 
-    __table __table_; 
- 
-public: 
-    typedef typename __table::pointer         pointer; 
-    typedef typename __table::const_pointer   const_pointer; 
-    typedef typename __table::size_type       size_type; 
-    typedef typename __table::difference_type difference_type; 
- 
-    typedef typename __table::const_iterator       iterator; 
-    typedef typename __table::const_iterator       const_iterator; 
-    typedef typename __table::const_local_iterator local_iterator; 
-    typedef typename __table::const_local_iterator const_local_iterator; 
- 
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+bool
+operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+           const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+{
+    if (__x.size() != __y.size())
+        return false;
+    typedef typename unordered_set<_Value, _Hash, _Pred, _Alloc>::const_iterator
+                                                                 const_iterator;
+    for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end();
+            __i != __ex; ++__i)
+    {
+        const_iterator __j = __y.find(*__i);
+        if (__j == __ey || !(*__i == *__j))
+            return false;
+    }
+    return true;
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+           const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+{
+    return !(__x == __y);
+}
+
+template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
+          class _Alloc = allocator<_Value> >
+class _LIBCPP_TEMPLATE_VIS unordered_multiset
+{
+public:
+    // types
+    typedef _Value                                                     key_type;
+    typedef key_type                                                   value_type;
+    typedef __identity_t<_Hash>                                        hasher;
+    typedef __identity_t<_Pred>                                        key_equal;
+    typedef __identity_t<_Alloc>                                       allocator_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    static_assert((is_same<value_type, typename allocator_type::value_type>::value),
+                  "Invalid allocator::value_type");
+
+private:
+    typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
+
+    __table __table_;
+
+public:
+    typedef typename __table::pointer         pointer;
+    typedef typename __table::const_pointer   const_pointer;
+    typedef typename __table::size_type       size_type;
+    typedef typename __table::difference_type difference_type;
+
+    typedef typename __table::const_iterator       iterator;
+    typedef typename __table::const_iterator       const_iterator;
+    typedef typename __table::const_local_iterator local_iterator;
+    typedef typename __table::const_local_iterator const_local_iterator;
+
 #if _LIBCPP_STD_VER > 14
     typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
 #endif
@@ -1144,148 +1144,148 @@ public:
     template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
         friend class _LIBCPP_TEMPLATE_VIS unordered_multiset;
 
-    _LIBCPP_INLINE_VISIBILITY 
-    unordered_multiset() 
-        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) 
-        { 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-            __get_db()->__insert_c(this); 
-#endif 
-        } 
-    explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(), 
-                                const key_equal& __eql = key_equal()); 
-    unordered_multiset(size_type __n, const hasher& __hf, 
-                       const key_equal& __eql, const allocator_type& __a); 
-#if _LIBCPP_STD_VER > 11 
-    inline _LIBCPP_INLINE_VISIBILITY 
-    unordered_multiset(size_type __n, const allocator_type& __a) 
-        : unordered_multiset(__n, hasher(), key_equal(), __a) {} 
-    inline _LIBCPP_INLINE_VISIBILITY 
-    unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a) 
-        : unordered_multiset(__n, __hf, key_equal(), __a) {} 
-#endif 
-    template <class _InputIterator> 
-        unordered_multiset(_InputIterator __first, _InputIterator __last); 
-    template <class _InputIterator> 
-        unordered_multiset(_InputIterator __first, _InputIterator __last, 
-                      size_type __n, const hasher& __hf = hasher(), 
-                      const key_equal& __eql = key_equal()); 
-    template <class _InputIterator> 
-        unordered_multiset(_InputIterator __first, _InputIterator __last, 
-                      size_type __n , const hasher& __hf, 
-                      const key_equal& __eql, const allocator_type& __a); 
-#if _LIBCPP_STD_VER > 11 
-    template <class _InputIterator> 
-    inline _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset()
+        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
+        {
+#if _LIBCPP_DEBUG_LEVEL == 2
+            __get_db()->__insert_c(this);
+#endif
+        }
+    explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(),
+                                const key_equal& __eql = key_equal());
+    unordered_multiset(size_type __n, const hasher& __hf,
+                       const key_equal& __eql, const allocator_type& __a);
+#if _LIBCPP_STD_VER > 11
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(size_type __n, const allocator_type& __a)
+        : unordered_multiset(__n, hasher(), key_equal(), __a) {}
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a)
+        : unordered_multiset(__n, __hf, key_equal(), __a) {}
+#endif
+    template <class _InputIterator>
+        unordered_multiset(_InputIterator __first, _InputIterator __last);
+    template <class _InputIterator>
+        unordered_multiset(_InputIterator __first, _InputIterator __last,
+                      size_type __n, const hasher& __hf = hasher(),
+                      const key_equal& __eql = key_equal());
+    template <class _InputIterator>
+        unordered_multiset(_InputIterator __first, _InputIterator __last,
+                      size_type __n , const hasher& __hf,
+                      const key_equal& __eql, const allocator_type& __a);
+#if _LIBCPP_STD_VER > 11
+    template <class _InputIterator>
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(_InputIterator __first, _InputIterator __last,
+                       size_type __n, const allocator_type& __a)
+        : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) {}
+    template <class _InputIterator>
+    inline _LIBCPP_INLINE_VISIBILITY
     unordered_multiset(_InputIterator __first, _InputIterator __last,
-                       size_type __n, const allocator_type& __a) 
-        : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) {} 
-    template <class _InputIterator> 
-    inline _LIBCPP_INLINE_VISIBILITY 
-    unordered_multiset(_InputIterator __first, _InputIterator __last, 
-                       size_type __n, const hasher& __hf, const allocator_type& __a) 
-        : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) {} 
-#endif 
-    _LIBCPP_INLINE_VISIBILITY 
-    explicit unordered_multiset(const allocator_type& __a); 
-    unordered_multiset(const unordered_multiset& __u); 
-    unordered_multiset(const unordered_multiset& __u, const allocator_type& __a); 
-#ifndef _LIBCPP_CXX03_LANG 
-    _LIBCPP_INLINE_VISIBILITY 
-    unordered_multiset(unordered_multiset&& __u) 
-        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value); 
-    unordered_multiset(unordered_multiset&& __u, const allocator_type& __a); 
-    unordered_multiset(initializer_list<value_type> __il); 
-    unordered_multiset(initializer_list<value_type> __il, size_type __n, 
-                       const hasher& __hf = hasher(), 
-                       const key_equal& __eql = key_equal()); 
-    unordered_multiset(initializer_list<value_type> __il, size_type __n, 
-                       const hasher& __hf, const key_equal& __eql, 
-                       const allocator_type& __a); 
-#if _LIBCPP_STD_VER > 11 
-    inline _LIBCPP_INLINE_VISIBILITY 
-    unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a) 
-      : unordered_multiset(__il, __n, hasher(), key_equal(), __a) {} 
-    inline _LIBCPP_INLINE_VISIBILITY 
-    unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a) 
-      : unordered_multiset(__il, __n, __hf, key_equal(), __a) {} 
-#endif 
-#endif // _LIBCPP_CXX03_LANG 
-    _LIBCPP_INLINE_VISIBILITY 
-    ~unordered_multiset() { 
-        static_assert(sizeof(__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), ""); 
-    } 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    unordered_multiset& operator=(const unordered_multiset& __u) 
-    { 
-        __table_ = __u.__table_; 
-        return *this; 
-    } 
-#ifndef _LIBCPP_CXX03_LANG 
-    _LIBCPP_INLINE_VISIBILITY 
-    unordered_multiset& operator=(unordered_multiset&& __u) 
-        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value); 
-    unordered_multiset& operator=(initializer_list<value_type> __il); 
-#endif // _LIBCPP_CXX03_LANG 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    allocator_type get_allocator() const _NOEXCEPT 
-        {return allocator_type(__table_.__node_alloc());} 
- 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 
-    bool      empty() const _NOEXCEPT {return __table_.size() == 0;} 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type size() const _NOEXCEPT  {return __table_.size();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type max_size() const _NOEXCEPT {return __table_.max_size();} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator       begin() _NOEXCEPT        {return __table_.begin();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator       end() _NOEXCEPT          {return __table_.end();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator begin()  const _NOEXCEPT {return __table_.begin();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator end()    const _NOEXCEPT {return __table_.end();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator cend()   const _NOEXCEPT {return __table_.end();} 
- 
-#ifndef _LIBCPP_CXX03_LANG 
-    template <class... _Args> 
-        _LIBCPP_INLINE_VISIBILITY 
-        iterator emplace(_Args&&... __args) 
-            {return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);} 
-    template <class... _Args> 
-        _LIBCPP_INLINE_VISIBILITY 
-        iterator emplace_hint(const_iterator __p, _Args&&... __args) 
-            {return __table_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));} 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator insert(const_iterator __p, value_type&& __x) 
-        {return __table_.__insert_multi(__p, _VSTD::move(__x));} 
-    _LIBCPP_INLINE_VISIBILITY 
-    void insert(initializer_list<value_type> __il) 
-        {insert(__il.begin(), __il.end());} 
-#endif // _LIBCPP_CXX03_LANG 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator insert(const_iterator __p, const value_type& __x) 
-        {return __table_.__insert_multi(__p, __x);} 
- 
-    template <class _InputIterator> 
-        _LIBCPP_INLINE_VISIBILITY 
-        void insert(_InputIterator __first, _InputIterator __last); 
- 
+                       size_type __n, const hasher& __hf, const allocator_type& __a)
+        : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) {}
+#endif
+    _LIBCPP_INLINE_VISIBILITY
+    explicit unordered_multiset(const allocator_type& __a);
+    unordered_multiset(const unordered_multiset& __u);
+    unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(unordered_multiset&& __u)
+        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+    unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
+    unordered_multiset(initializer_list<value_type> __il);
+    unordered_multiset(initializer_list<value_type> __il, size_type __n,
+                       const hasher& __hf = hasher(),
+                       const key_equal& __eql = key_equal());
+    unordered_multiset(initializer_list<value_type> __il, size_type __n,
+                       const hasher& __hf, const key_equal& __eql,
+                       const allocator_type& __a);
+#if _LIBCPP_STD_VER > 11
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
+      : unordered_multiset(__il, __n, hasher(), key_equal(), __a) {}
+    inline _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_multiset(__il, __n, __hf, key_equal(), __a) {}
+#endif
+#endif // _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    ~unordered_multiset() {
+        static_assert(sizeof(__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset& operator=(const unordered_multiset& __u)
+    {
+        __table_ = __u.__table_;
+        return *this;
+    }
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset& operator=(unordered_multiset&& __u)
+        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
+    unordered_multiset& operator=(initializer_list<value_type> __il);
+#endif // _LIBCPP_CXX03_LANG
+
+    _LIBCPP_INLINE_VISIBILITY
+    allocator_type get_allocator() const _NOEXCEPT
+        {return allocator_type(__table_.__node_alloc());}
+
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
+    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
+    _LIBCPP_INLINE_VISIBILITY
+    size_type size() const _NOEXCEPT  {return __table_.size();}
+    _LIBCPP_INLINE_VISIBILITY
+    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator       begin() _NOEXCEPT        {return __table_.begin();}
+    _LIBCPP_INLINE_VISIBILITY
+    iterator       end() _NOEXCEPT          {return __table_.end();}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator end()    const _NOEXCEPT {return __table_.end();}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
+
+#ifndef _LIBCPP_CXX03_LANG
+    template <class... _Args>
+        _LIBCPP_INLINE_VISIBILITY
+        iterator emplace(_Args&&... __args)
+            {return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
+    template <class... _Args>
+        _LIBCPP_INLINE_VISIBILITY
+        iterator emplace_hint(const_iterator __p, _Args&&... __args)
+            {return __table_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));}
+    _LIBCPP_INLINE_VISIBILITY
+    iterator insert(const_iterator __p, value_type&& __x)
+        {return __table_.__insert_multi(__p, _VSTD::move(__x));}
+    _LIBCPP_INLINE_VISIBILITY
+    void insert(initializer_list<value_type> __il)
+        {insert(__il.begin(), __il.end());}
+#endif // _LIBCPP_CXX03_LANG
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator insert(const_iterator __p, const value_type& __x)
+        {return __table_.__insert_multi(__p, __x);}
+
+    template <class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY
+        void insert(_InputIterator __first, _InputIterator __last);
+
 #if _LIBCPP_STD_VER > 14
-    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_INLINE_VISIBILITY
     iterator insert(node_type&& __nh)
     {
         _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
@@ -1348,430 +1348,430 @@ public:
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __p) {return __table_.erase(__p);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator erase(const_iterator __first, const_iterator __last) 
-        {return __table_.erase(__first, __last);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    void clear() _NOEXCEPT {__table_.clear();} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    void swap(unordered_multiset& __u) 
-        _NOEXCEPT_(__is_nothrow_swappable<__table>::value) 
-        {__table_.swap(__u.__table_);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    hasher hash_function() const {return __table_.hash_function();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    key_equal key_eq() const {return __table_.key_eq();} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator       find(const key_type& __k)       {return __table_.find(__k);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator find(const key_type& __k) const {return __table_.find(__k);} 
-#if _LIBCPP_STD_VER > 17 
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    iterator       find(const _K2& __k)            {return __table_.find(__k);} 
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_iterator find(const _K2& __k) const      {return __table_.find(__k);} 
-#endif // _LIBCPP_STD_VER > 17 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type count(const key_type& __k) const {return __table_.__count_multi(__k);} 
-#if _LIBCPP_STD_VER > 17 
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type count(const _K2& __k) const      {return __table_.__count_multi(__k);} 
-#endif // _LIBCPP_STD_VER > 17 
- 
-#if _LIBCPP_STD_VER > 17 
-    _LIBCPP_INLINE_VISIBILITY 
-    bool contains(const key_type& __k) const {return find(__k) != end();} 
- 
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    bool contains(const _K2& __k) const      {return find(__k) != end();} 
-#endif // _LIBCPP_STD_VER > 17 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    pair<iterator, iterator>             equal_range(const key_type& __k) 
-        {return __table_.__equal_range_multi(__k);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    pair<const_iterator, const_iterator> equal_range(const key_type& __k) const 
-        {return __table_.__equal_range_multi(__k);} 
-#if _LIBCPP_STD_VER > 17 
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    pair<iterator, iterator>             equal_range(const _K2& __k) 
-        {return __table_.__equal_range_multi(__k);} 
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> 
-    _LIBCPP_INLINE_VISIBILITY 
-    pair<const_iterator, const_iterator> equal_range(const _K2& __k) const 
-        {return __table_.__equal_range_multi(__k);} 
-#endif // _LIBCPP_STD_VER > 17 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    size_type bucket(const key_type& __k) const {return __table_.bucket(__k);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    local_iterator       begin(size_type __n)        {return __table_.begin(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    local_iterator       end(size_type __n)          {return __table_.end(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_local_iterator begin(size_type __n) const  {return __table_.cbegin(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_local_iterator end(size_type __n) const    {return __table_.cend(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);} 
- 
-    _LIBCPP_INLINE_VISIBILITY 
-    float load_factor() const _NOEXCEPT {return __table_.load_factor();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();} 
-    _LIBCPP_INLINE_VISIBILITY 
-    void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    void rehash(size_type __n) {__table_.rehash(__n);} 
-    _LIBCPP_INLINE_VISIBILITY 
-    void reserve(size_type __n) {__table_.reserve(__n);} 
- 
-#if _LIBCPP_DEBUG_LEVEL == 2 
- 
-    bool __dereferenceable(const const_iterator* __i) const 
-        {return __table_.__dereferenceable(__i);} 
-    bool __decrementable(const const_iterator* __i) const 
-        {return __table_.__decrementable(__i);} 
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const 
-        {return __table_.__addable(__i, __n);} 
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const 
-        {return __table_.__addable(__i, __n);} 
- 
-#endif // _LIBCPP_DEBUG_LEVEL == 2 
- 
-}; 
- 
-#if _LIBCPP_STD_VER >= 17 
-template<class _InputIterator, 
-         class _Hash = hash<__iter_value_type<_InputIterator>>, 
-         class _Pred = equal_to<__iter_value_type<_InputIterator>>, 
-         class _Allocator = allocator<__iter_value_type<_InputIterator>>, 
-         class = enable_if_t<!__is_allocator<_Hash>::value>, 
-         class = enable_if_t<!is_integral<_Hash>::value>, 
-         class = enable_if_t<!__is_allocator<_Pred>::value>, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0, 
-              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) 
-  -> unordered_multiset<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>; 
- 
-template<class _Tp, class _Hash = hash<_Tp>, 
-         class _Pred = equal_to<_Tp>, class _Allocator = allocator<_Tp>, 
-         class = enable_if_t<!__is_allocator<_Hash>::value>, 
-         class = enable_if_t<!is_integral<_Hash>::value>, 
-         class = enable_if_t<!__is_allocator<_Pred>::value>, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type = 0, 
-              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) 
-  -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>; 
- 
-template<class _InputIterator, class _Allocator, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator) 
-  -> unordered_multiset<__iter_value_type<_InputIterator>, 
-                   hash<__iter_value_type<_InputIterator>>, 
-                   equal_to<__iter_value_type<_InputIterator>>, 
-                   _Allocator>; 
- 
-template<class _InputIterator, class _Hash, class _Allocator, 
-         class = enable_if_t<!__is_allocator<_Hash>::value>, 
-         class = enable_if_t<!is_integral<_Hash>::value>, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, 
-              _Hash, _Allocator) 
-  -> unordered_multiset<__iter_value_type<_InputIterator>, _Hash, 
-                   equal_to<__iter_value_type<_InputIterator>>, 
-                   _Allocator>; 
- 
-template<class _Tp, class _Allocator, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator) 
-  -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>; 
- 
-template<class _Tp, class _Hash, class _Allocator, 
-         class = enable_if_t<!__is_allocator<_Hash>::value>, 
-         class = enable_if_t<!is_integral<_Hash>::value>, 
-         class = enable_if_t<__is_allocator<_Allocator>::value>> 
-unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator) 
-  -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>; 
-#endif 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        size_type __n, const hasher& __hf, const key_equal& __eql) 
-    : __table_(__hf, __eql) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        size_type __n, const hasher& __hf, const key_equal& __eql, 
-        const allocator_type& __a) 
-    : __table_(__hf, __eql, __a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-template <class _InputIterator> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        _InputIterator __first, _InputIterator __last) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    insert(__first, __last); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-template <class _InputIterator> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        _InputIterator __first, _InputIterator __last, size_type __n, 
-        const hasher& __hf, const key_equal& __eql) 
-    : __table_(__hf, __eql) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-    insert(__first, __last); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-template <class _InputIterator> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        _InputIterator __first, _InputIterator __last, size_type __n, 
-        const hasher& __hf, const key_equal& __eql, const allocator_type& __a) 
-    : __table_(__hf, __eql, __a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-    insert(__first, __last); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        const allocator_type& __a) 
-    : __table_(__a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        const unordered_multiset& __u) 
-    : __table_(__u.__table_) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__u.bucket_count()); 
-    insert(__u.begin(), __u.end()); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        const unordered_multiset& __u, const allocator_type& __a) 
-    : __table_(__u.__table_, __a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__u.bucket_count()); 
-    insert(__u.begin(), __u.end()); 
-} 
- 
-#ifndef _LIBCPP_CXX03_LANG 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        unordered_multiset&& __u) 
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value) 
-    : __table_(_VSTD::move(__u.__table_)) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-    __get_db()->swap(this, &__u); 
-#endif 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        unordered_multiset&& __u, const allocator_type& __a) 
-    : __table_(_VSTD::move(__u.__table_), __a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    if (__a != __u.get_allocator()) 
-    { 
-        iterator __i = __u.begin(); 
-        while (__u.size() != 0) 
-            __table_.__insert_multi(_VSTD::move(__u.__table_.remove(__i++)->__value_)); 
-    } 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    else 
-        __get_db()->swap(this, &__u); 
-#endif 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        initializer_list<value_type> __il) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    insert(__il.begin(), __il.end()); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf, 
-        const key_equal& __eql) 
-    : __table_(__hf, __eql) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-    insert(__il.begin(), __il.end()); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( 
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf, 
-        const key_equal& __eql, const allocator_type& __a) 
-    : __table_(__hf, __eql, __a) 
-{ 
-#if _LIBCPP_DEBUG_LEVEL == 2 
-    __get_db()->__insert_c(this); 
-#endif 
-    __table_.rehash(__n); 
-    insert(__il.begin(), __il.end()); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>& 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=( 
-        unordered_multiset&& __u) 
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) 
-{ 
-    __table_ = _VSTD::move(__u.__table_); 
-    return *this; 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>& 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=( 
-        initializer_list<value_type> __il) 
-{ 
-    __table_.__assign_multi(__il.begin(), __il.end()); 
-    return *this; 
-} 
- 
-#endif // _LIBCPP_CXX03_LANG 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-template <class _InputIterator> 
-inline 
-void 
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, 
-                                                         _InputIterator __last) 
-{ 
-    for (; __first != __last; ++__first) 
-        __table_.__insert_multi(*__first); 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline _LIBCPP_INLINE_VISIBILITY 
-void 
-swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, 
-     unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) 
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) 
-{ 
-    __x.swap(__y); 
-} 
- 
+    iterator erase(const_iterator __p) {return __table_.erase(__p);}
+    _LIBCPP_INLINE_VISIBILITY
+    size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
+    _LIBCPP_INLINE_VISIBILITY
+    iterator erase(const_iterator __first, const_iterator __last)
+        {return __table_.erase(__first, __last);}
+    _LIBCPP_INLINE_VISIBILITY
+    void clear() _NOEXCEPT {__table_.clear();}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void swap(unordered_multiset& __u)
+        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
+        {__table_.swap(__u.__table_);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    hasher hash_function() const {return __table_.hash_function();}
+    _LIBCPP_INLINE_VISIBILITY
+    key_equal key_eq() const {return __table_.key_eq();}
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator       find(const key_type& __k)       {return __table_.find(__k);}
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator find(const key_type& __k) const {return __table_.find(__k);}
+#if _LIBCPP_STD_VER > 17
+    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    iterator       find(const _K2& __k)            {return __table_.find(__k);}
+    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    const_iterator find(const _K2& __k) const      {return __table_.find(__k);}
+#endif // _LIBCPP_STD_VER > 17
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
+#if _LIBCPP_STD_VER > 17
+    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    size_type count(const _K2& __k) const      {return __table_.__count_multi(__k);}
+#endif // _LIBCPP_STD_VER > 17
+
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY
+    bool contains(const key_type& __k) const {return find(__k) != end();}
+
+    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    bool contains(const _K2& __k) const      {return find(__k) != end();}
+#endif // _LIBCPP_STD_VER > 17
+
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, iterator>             equal_range(const key_type& __k)
+        {return __table_.__equal_range_multi(__k);}
+    _LIBCPP_INLINE_VISIBILITY
+    pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
+        {return __table_.__equal_range_multi(__k);}
+#if _LIBCPP_STD_VER > 17
+    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<iterator, iterator>             equal_range(const _K2& __k)
+        {return __table_.__equal_range_multi(__k);}
+    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
+    _LIBCPP_INLINE_VISIBILITY
+    pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
+        {return __table_.__equal_range_multi(__k);}
+#endif // _LIBCPP_STD_VER > 17
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
+    _LIBCPP_INLINE_VISIBILITY
+    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    local_iterator       begin(size_type __n)        {return __table_.begin(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    local_iterator       end(size_type __n)          {return __table_.end(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    const_local_iterator begin(size_type __n) const  {return __table_.cbegin(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    const_local_iterator end(size_type __n) const    {return __table_.cend(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}
+
+    _LIBCPP_INLINE_VISIBILITY
+    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
+    _LIBCPP_INLINE_VISIBILITY
+    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
+    _LIBCPP_INLINE_VISIBILITY
+    void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
+    _LIBCPP_INLINE_VISIBILITY
+    void rehash(size_type __n) {__table_.rehash(__n);}
+    _LIBCPP_INLINE_VISIBILITY
+    void reserve(size_type __n) {__table_.reserve(__n);}
+
+#if _LIBCPP_DEBUG_LEVEL == 2
+
+    bool __dereferenceable(const const_iterator* __i) const
+        {return __table_.__dereferenceable(__i);}
+    bool __decrementable(const const_iterator* __i) const
+        {return __table_.__decrementable(__i);}
+    bool __addable(const const_iterator* __i, ptrdiff_t __n) const
+        {return __table_.__addable(__i, __n);}
+    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
+        {return __table_.__addable(__i, __n);}
+
+#endif // _LIBCPP_DEBUG_LEVEL == 2
+
+};
+
+#if _LIBCPP_STD_VER >= 17
+template<class _InputIterator,
+         class _Hash = hash<__iter_value_type<_InputIterator>>,
+         class _Pred = equal_to<__iter_value_type<_InputIterator>>,
+         class _Allocator = allocator<__iter_value_type<_InputIterator>>,
+         class = enable_if_t<!__is_allocator<_Hash>::value>,
+         class = enable_if_t<!is_integral<_Hash>::value>,
+         class = enable_if_t<!__is_allocator<_Pred>::value>,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_multiset<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
+
+template<class _Tp, class _Hash = hash<_Tp>,
+         class _Pred = equal_to<_Tp>, class _Allocator = allocator<_Tp>,
+         class = enable_if_t<!__is_allocator<_Hash>::value>,
+         class = enable_if_t<!is_integral<_Hash>::value>,
+         class = enable_if_t<!__is_allocator<_Pred>::value>,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+  -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>;
+
+template<class _InputIterator, class _Allocator,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_multiset<__iter_value_type<_InputIterator>,
+                   hash<__iter_value_type<_InputIterator>>,
+                   equal_to<__iter_value_type<_InputIterator>>,
+                   _Allocator>;
+
+template<class _InputIterator, class _Hash, class _Allocator,
+         class = enable_if_t<!__is_allocator<_Hash>::value>,
+         class = enable_if_t<!is_integral<_Hash>::value>,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type,
+              _Hash, _Allocator)
+  -> unordered_multiset<__iter_value_type<_InputIterator>, _Hash,
+                   equal_to<__iter_value_type<_InputIterator>>,
+                   _Allocator>;
+
+template<class _Tp, class _Allocator,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
+  -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
+template<class _Tp, class _Hash, class _Allocator,
+         class = enable_if_t<!__is_allocator<_Hash>::value>,
+         class = enable_if_t<!is_integral<_Hash>::value>,
+         class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+  -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
+#endif
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        size_type __n, const hasher& __hf, const key_equal& __eql,
+        const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        _InputIterator __first, _InputIterator __last)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        _InputIterator __first, _InputIterator __last, size_type __n,
+        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+    insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        const allocator_type& __a)
+    : __table_(__a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        const unordered_multiset& __u)
+    : __table_(__u.__table_)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__u.bucket_count());
+    insert(__u.begin(), __u.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        const unordered_multiset& __u, const allocator_type& __a)
+    : __table_(__u.__table_, __a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__u.bucket_count());
+    insert(__u.begin(), __u.end());
+}
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        unordered_multiset&& __u)
+    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
+    : __table_(_VSTD::move(__u.__table_))
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+    __get_db()->swap(this, &__u);
+#endif
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        unordered_multiset&& __u, const allocator_type& __a)
+    : __table_(_VSTD::move(__u.__table_), __a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    if (__a != __u.get_allocator())
+    {
+        iterator __i = __u.begin();
+        while (__u.size() != 0)
+            __table_.__insert_multi(_VSTD::move(__u.__table_.remove(__i++)->__value_));
+    }
+#if _LIBCPP_DEBUG_LEVEL == 2
+    else
+        __get_db()->swap(this, &__u);
+#endif
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        initializer_list<value_type> __il)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    insert(__il.begin(), __il.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
+        const key_equal& __eql)
+    : __table_(__hf, __eql)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+    insert(__il.begin(), __il.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
+        const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a)
+{
+#if _LIBCPP_DEBUG_LEVEL == 2
+    __get_db()->__insert_c(this);
+#endif
+    __table_.rehash(__n);
+    insert(__il.begin(), __il.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
+        unordered_multiset&& __u)
+    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
+{
+    __table_ = _VSTD::move(__u.__table_);
+    return *this;
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
+        initializer_list<value_type> __il)
+{
+    __table_.__assign_multi(__il.begin(), __il.end());
+    return *this;
+}
+
+#endif // _LIBCPP_CXX03_LANG
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline
+void
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
+                                                         _InputIterator __last)
+{
+    for (; __first != __last; ++__first)
+        __table_.__insert_multi(*__first);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+     unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
+{
+    __x.swap(__y);
+}
+
 #if _LIBCPP_STD_VER > 17
-template <class _Value, class _Hash, class _Pred, class _Alloc, 
-          class _Predicate> 
+template <class _Value, class _Hash, class _Pred, class _Alloc,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-    typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::size_type 
-    erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c, 
-             _Predicate __pred) { 
-  return _VSTD::__libcpp_erase_if_container(__c, __pred); 
-} 
+    typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::size_type
+    erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c,
+             _Predicate __pred) {
+  return _VSTD::__libcpp_erase_if_container(__c, __pred);
+}
 #endif
 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-bool 
-operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, 
-           const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) 
-{ 
-    if (__x.size() != __y.size()) 
-        return false; 
-    typedef typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::const_iterator 
-                                                                 const_iterator; 
-    typedef pair<const_iterator, const_iterator> _EqRng; 
-    for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;) 
-    { 
-        _EqRng __xeq = __x.equal_range(*__i); 
-        _EqRng __yeq = __y.equal_range(*__i); 
-        if (_VSTD::distance(__xeq.first, __xeq.second) != 
-            _VSTD::distance(__yeq.first, __yeq.second) || 
-                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first)) 
-            return false; 
-        __i = __xeq.second; 
-    } 
-    return true; 
-} 
- 
-template <class _Value, class _Hash, class _Pred, class _Alloc> 
-inline _LIBCPP_INLINE_VISIBILITY 
-bool 
-operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, 
-           const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) 
-{ 
-    return !(__x == __y); 
-} 
- 
-_LIBCPP_END_NAMESPACE_STD 
- 
-#endif // _LIBCPP_UNORDERED_SET 
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+bool
+operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+           const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+{
+    if (__x.size() != __y.size())
+        return false;
+    typedef typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::const_iterator
+                                                                 const_iterator;
+    typedef pair<const_iterator, const_iterator> _EqRng;
+    for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;)
+    {
+        _EqRng __xeq = __x.equal_range(*__i);
+        _EqRng __yeq = __y.equal_range(*__i);
+        if (_VSTD::distance(__xeq.first, __xeq.second) !=
+            _VSTD::distance(__yeq.first, __yeq.second) ||
+                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+            return false;
+        __i = __xeq.second;
+    }
+    return true;
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+           const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+{
+    return !(__x == __y);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_UNORDERED_SET