diff --git a/doc/unordered/unordered_flat_map.adoc b/doc/unordered/unordered_flat_map.adoc
index 8d747f55..777bd347 100644
--- a/doc/unordered/unordered_flat_map.adoc
+++ b/doc/unordered/unordered_flat_map.adoc
@@ -73,6 +73,8 @@ namespace boost {
                          const allocator_type& a = allocator_type());
     xref:#unordered_flat_map_copy_constructor[unordered_flat_map](const unordered_flat_map& other);
     xref:#unordered_flat_map_move_constructor[unordered_flat_map](unordered_flat_map&& other);
+    template<class InputIterator>
+      xref:#unordered_flat_map_iterator_range_constructor_with_allocator[unordered_flat_map](InputIterator f, InputIterator l, const allocator_type& a);
     explicit xref:#unordered_flat_map_allocator_constructor[unordered_flat_map](const Allocator& a);
     xref:#unordered_flat_map_copy_constructor_with_allocator[unordered_flat_map](const unordered_flat_map& other, const Allocator& a);
     xref:#unordered_flat_map_move_constructor_with_allocator[unordered_flat_map](unordered_flat_map&& other, const Allocator& a);
@@ -88,6 +90,7 @@ namespace boost {
     template<class InputIterator>
       xref:#unordered_flat_map_iterator_range_constructor_with_bucket_count_and_hasher[unordered_flat_map](InputIterator f, InputIterator l, size_type n, const hasher& hf,
                          const allocator_type& a);
+    xref:#unordered_flat_map_initializer_list_constructor_with_allocator[unordered_flat_map](std::initializer_list<value_type> il, const allocator_type& a);
     xref:#unordered_flat_map_initializer_list_constructor_with_bucket_count_and_allocator[unordered_flat_map](std::initializer_list<value_type> il, size_type n,
                        const allocator_type& a);
     xref:#unordered_flat_map_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_flat_map](std::initializer_list<value_type> il, size_type n, const hasher& hf,
@@ -368,6 +371,19 @@ The hash function, predicate and allocator are moved-constructed from `other`.
 
 ---
 
+==== Iterator Range Constructor with Allocator
+```c++
+template<class InputIterator>
+  unordered_flat_map(InputIterator f, InputIterator l, const allocator_type& a);
+```
+
+Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
+
+[horizontal]
+Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== Allocator Constructor
 ```c++
 explicit unordered_flat_map(Allocator const& a);
@@ -469,6 +485,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
 
 ---
 
+==== initializer_list Constructor with Allocator
+
+```c++
+unordered_flat_map(std::initializer_list<value_type> il, const allocator_type& a);
+```
+
+Constructs an empty container using `a` and default hash function and key equality predicate, and inserts the elements from `il` into it.
+
+[horizontal]
+Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== initializer_list Constructor with Bucket Count and Allocator
 
 ```c++
diff --git a/doc/unordered/unordered_flat_set.adoc b/doc/unordered/unordered_flat_set.adoc
index 0fff40d3..0079246e 100644
--- a/doc/unordered/unordered_flat_set.adoc
+++ b/doc/unordered/unordered_flat_set.adoc
@@ -68,6 +68,8 @@ namespace boost {
                          const allocator_type& a = allocator_type());
     xref:#unordered_flat_set_copy_constructor[unordered_flat_set](const unordered_flat_set& other);
     xref:#unordered_flat_set_move_constructor[unordered_flat_set](unordered_flat_set&& other);
+    template<class InputIterator>
+      xref:#unordered_flat_set_iterator_range_constructor_with_allocator[unordered_flat_set](InputIterator f, InputIterator l, const allocator_type& a);
     explicit xref:#unordered_flat_set_allocator_constructor[unordered_flat_set](const Allocator& a);
     xref:#unordered_flat_set_copy_constructor_with_allocator[unordered_flat_set](const unordered_flat_set& other, const Allocator& a);
     xref:#unordered_flat_set_move_constructor_with_allocator[unordered_flat_set](unordered_flat_set&& other, const Allocator& a);
@@ -83,6 +85,7 @@ namespace boost {
     template<class InputIterator>
       xref:#unordered_flat_set_iterator_range_constructor_with_bucket_count_and_hasher[unordered_flat_set](InputIterator f, InputIterator l, size_type n, const hasher& hf,
                          const allocator_type& a);
+    xref:#unordered_flat_set_initializer_list_constructor_with_allocator[unordered_flat_set](std::initializer_list<value_type> il, const allocator_type& a);
     xref:#unordered_flat_set_initializer_list_constructor_with_bucket_count_and_allocator[unordered_flat_set](std::initializer_list<value_type> il, size_type n,
                        const allocator_type& a);
     xref:#unordered_flat_set_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_flat_set](std::initializer_list<value_type> il, size_type n, const hasher& hf,
@@ -332,6 +335,19 @@ The hash function, predicate and allocator are moved-constructed from `other`.
 
 ---
 
+==== Iterator Range Constructor with Allocator
+```c++
+template<class InputIterator>
+  unordered_flat_set(InputIterator f, InputIterator l, const allocator_type& a);
+```
+
+Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and inserts the elements from `[f, l)` into it.
+
+[horizontal]
+Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== Allocator Constructor
 ```c++
 explicit unordered_flat_set(Allocator const& a);
@@ -433,6 +449,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
 
 ---
 
+==== initializer_list Constructor with Allocator
+
+```c++
+unordered_flat_set(std::initializer_list<value_type> il, const allocator_type& a);
+```
+
+Constructs an empty container using `a` and default hash function and key equality predicate, and inserts the elements from `il` into it.
+
+[horizontal]
+Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== initializer_list Constructor with Bucket Count and Allocator
 
 ```c++
diff --git a/doc/unordered/unordered_map.adoc b/doc/unordered/unordered_map.adoc
index 5b8f1f92..bcd7a86f 100644
--- a/doc/unordered/unordered_map.adoc
+++ b/doc/unordered/unordered_map.adoc
@@ -54,6 +54,8 @@ namespace boost {
                     const allocator_type& a = allocator_type());
     xref:#unordered_map_copy_constructor[unordered_map](const unordered_map& other);
     xref:#unordered_map_move_constructor[unordered_map](unordered_map&& other);
+    template<class InputIterator>
+      xref:#unordered_map_iterator_range_constructor_with_allocator[unordered_map](InputIterator f, InputIterator l, const allocator_type& a);
     explicit xref:#unordered_map_allocator_constructor[unordered_map](const Allocator& a);
     xref:#unordered_map_copy_constructor_with_allocator[unordered_map](const unordered_map& other, const Allocator& a);
     xref:#unordered_map_move_constructor_with_allocator[unordered_map](unordered_map&& other, const Allocator& a);
@@ -69,6 +71,7 @@ namespace boost {
     template<class InputIterator>
       xref:#unordered_map_iterator_range_constructor_with_bucket_count_and_hasher[unordered_map](InputIterator f, InputIterator l, size_type n, const hasher& hf,
                     const allocator_type& a);
+    xref:#unordered_map_initializer_list_constructor_with_allocator[unordered_map](std::initializer_list<value_type> il, const allocator_type& a);
     xref:#unordered_map_initializer_list_constructor_with_bucket_count_and_allocator[unordered_map](std::initializer_list<value_type> il, size_type n, const allocator_type& a);
     xref:#unordered_map_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_map](std::initializer_list<value_type> il, size_type n, const hasher& hf,
                   const allocator_type& a);
@@ -450,6 +453,19 @@ So, for example, you can't return the container from a function.
 
 ---
 
+==== Iterator Range Constructor with Allocator
+```c++
+template<class InputIterator>
+  unordered_map(InputIterator f, InputIterator l, const allocator_type& a);
+```
+
+Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and a maximum load factor of `1.0` and inserts the elements from `[f, l)` into it.
+
+[horizontal]
+Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== Allocator Constructor
 ```c++
 explicit unordered_map(Allocator const& a);
@@ -553,6 +569,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
 
 ---
 
+==== initializer_list Constructor with Allocator
+
+```c++
+unordered_map(std::initializer_list<value_type> il, const allocator_type& a);
+```
+
+Constructs an empty container using `a` as the allocator and a maximum load factor of 1.0 and inserts the elements from `il` into it.
+
+[horizontal]
+Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== initializer_list Constructor with Bucket Count and Allocator
 
 ```c++
diff --git a/doc/unordered/unordered_multimap.adoc b/doc/unordered/unordered_multimap.adoc
index f40e8870..b66b0edd 100644
--- a/doc/unordered/unordered_multimap.adoc
+++ b/doc/unordered/unordered_multimap.adoc
@@ -53,6 +53,8 @@ namespace boost {
                          const allocator_type& a = allocator_type());
     xref:#unordered_multimap_copy_constructor[unordered_multimap](const unordered_multimap& other);
     xref:#unordered_multimap_move_constructor[unordered_multimap](unordered_multimap&& other);
+    template<class InputIterator>
+      xref:#unordered_multimap_iterator_range_constructor_with_allocator[unordered_multimap](InputIterator f, InputIterator l, const allocator_type& a);
     explicit xref:#unordered_multimap_allocator_constructor[unordered_multimap](const Allocator& a);
     xref:#unordered_multimap_copy_constructor_with_allocator[unordered_multimap](const unordered_multimap& other, const Allocator& a);
     xref:#unordered_multimap_move_constructor_with_allocator[unordered_multimap](unordered_multimap&& other, const Allocator& a);
@@ -68,7 +70,9 @@ namespace boost {
     template<class InputIterator>
       xref:#unordered_multimap_iterator_range_constructor_with_bucket_count_and_hasher[unordered_multimap](InputIterator f, InputIterator l, size_type n, const hasher& hf,
                          const allocator_type& a);
-    xref:#unordered_multimap_initializer_list_constructor_with_bucket_count_and_allocator[unordered_multimap](std::initializer_list<value_type> il, size_type n, const allocator_type& a);
+    xref:#unordered_multimap_initializer_list_constructor_with_allocator[unordered_multimap](std::initializer_list<value_type> il, const allocator_type& a);
+    xref:#unordered_multimap_initializer_list_constructor_with_bucket_count_and_allocator[unordered_multimap](std::initializer_list<value_type> il, size_type n,
+                       const allocator_type& a);
     xref:#unordered_multimap_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_multimap](std::initializer_list<value_type> il, size_type n, const hasher& hf,
                        const allocator_type& a);
     xref:#unordered_multimap_destructor[~unordered_multimap]();
@@ -416,6 +420,19 @@ So, for example, you can't return the container from a function.
 
 ---
 
+==== Iterator Range Constructor with Allocator
+```c++
+template<class InputIterator>
+  unordered_multimap(InputIterator f, InputIterator l, const allocator_type& a);
+```
+
+Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and a maximum load factor of `1.0` and inserts the elements from `[f, l)` into it.
+
+[horizontal]
+Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== Allocator Constructor
 ```c++
 explicit unordered_multimap(const Allocator& a);
@@ -518,6 +535,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
 
 ---
 
+==== initializer_list Constructor with Allocator
+
+```c++
+unordered_multimap(std::initializer_list<value_type> il, const allocator_type& a);
+```
+
+Constructs an empty container using `a` as the allocator and a maximum load factor of 1.0 and inserts the elements from `il` into it.
+
+[horizontal]
+Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== initializer_list Constructor with Bucket Count and Allocator
 
 ```c++
diff --git a/doc/unordered/unordered_multiset.adoc b/doc/unordered/unordered_multiset.adoc
index 3bd62c19..de4f39d7 100644
--- a/doc/unordered/unordered_multiset.adoc
+++ b/doc/unordered/unordered_multiset.adoc
@@ -51,6 +51,8 @@ namespace boost {
                          const allocator_type& a = allocator_type());
     xref:#unordered_multiset_copy_constructor[unordered_multiset](const unordered_multiset& other);
     xref:#unordered_multiset_move_constructor[unordered_multiset](unordered_multiset&& other);
+    template<class InputIterator>
+      xref:#unordered_multiset_iterator_range_constructor_with_allocator[unordered_multiset](InputIterator f, InputIterator l, const allocator_type& a);
     explicit xref:#unordered_multiset_allocator_constructor[unordered_multiset](const Allocator& a);
     xref:#unordered_multiset_copy_constructor_with_allocator[unordered_multiset](const unordered_multiset& other, const Allocator& a);
     xref:#unordered_multiset_move_constructor_with_allocator[unordered_multiset](unordered_multiset&& other, const Allocator& a);
@@ -66,7 +68,9 @@ namespace boost {
     template<class InputIterator>
       xref:#unordered_multiset_iterator_range_constructor_with_bucket_count_and_hasher[unordered_multiset](InputIterator f, InputIterator l, size_type n, const hasher& hf,
                          const allocator_type& a);
-    xref:#unordered_multiset_initializer_list_constructor_with_bucket_count_and_allocator[unordered_multiset](std::initializer_list<value_type> il, size_type n, const allocator_type& a)
+    xref:#unordered_multiset_initializer_list_constructor_with_allocator[unordered_multiset](std::initializer_list<value_type> il, const allocator_type& a);
+    xref:#unordered_multiset_initializer_list_constructor_with_bucket_count_and_allocator[unordered_multiset](std::initializer_list<value_type> il, size_type n,
+                       const allocator_type& a)
     xref:#unordered_multiset_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_multiset](std::initializer_list<value_type> il, size_type n, const hasher& hf,
                        const allocator_type& a);
     xref:#unordered_multiset_destructor[~unordered_multiset()];
@@ -409,6 +413,19 @@ So, for example, you can't return the container from a function.
 
 ---
 
+==== Iterator Range Constructor with Allocator
+```c++
+template<class InputIterator>
+  unordered_multiset(InputIterator f, InputIterator l, const allocator_type& a);
+```
+
+Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and a maximum load factor of `1.0` and inserts the elements from `[f, l)` into it.
+
+[horizontal]
+Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== Allocator Constructor
 ```c++
 explicit unordered_multiset(const Allocator& a);
@@ -512,6 +529,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
 
 ---
 
+==== initializer_list Constructor with Allocator
+
+```c++
+unordered_multiset(std::initializer_list<value_type> il, const allocator_type& a);
+```
+
+Constructs an empty container using `a` as the allocator and a maximum load factor of 1.0 and inserts the elements from `il` into it.
+
+[horizontal]
+Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== initializer_list Constructor with Bucket Count and Allocator
 
 ```c++
diff --git a/doc/unordered/unordered_set.adoc b/doc/unordered/unordered_set.adoc
index 63d973b7..99b7442a 100644
--- a/doc/unordered/unordered_set.adoc
+++ b/doc/unordered/unordered_set.adoc
@@ -52,6 +52,8 @@ namespace boost {
                     const allocator_type& a = allocator_type());
     xref:#unordered_set_copy_constructor[unordered_set](const unordered_set& other);
     xref:#unordered_set_move_constructor[unordered_set](unordered_set&& other);
+    template<class InputIterator>
+      xref:#unordered_set_iterator_range_constructor_with_allocator[unordered_set](InputIterator f, InputIterator l, const allocator_type& a);
     explicit xref:#unordered_set_allocator_constructor[unordered_set](const Allocator& a);
     xref:#unordered_set_copy_constructor_with_allocator[unordered_set](const unordered_set& other, const Allocator& a);
     xref:#unordered_set_move_constructor_with_allocator[unordered_set](unordered_set&& other, const Allocator& a);
@@ -67,6 +69,7 @@ namespace boost {
     template<class InputIterator>
       xref:#unordered_set_iterator_range_constructor_with_bucket_count_and_hasher[unordered_set](InputIterator f, InputIterator l, size_type n, const hasher& hf,
                     const allocator_type& a);
+    xref:#unordered_set_initializer_list_constructor_with_allocator[unordered_set](std::initializer_list<value_type> il, const allocator_type& a);
     xref:#unordered_set_initializer_list_constructor_with_bucket_count_and_allocator[unordered_set](std::initializer_list<value_type> il, size_type n, const allocator_type& a);
     xref:#unordered_set_initializer_list_constructor_with_bucket_count_and_hasher_and_allocator[unordered_set](std::initializer_list<value_type> il, size_type n, const hasher& hf,
                   const allocator_type& a);
@@ -420,6 +423,19 @@ So, for example, you can't return the container from a function.
 
 ---
 
+==== Iterator Range Constructor with Allocator
+```c++
+template<class InputIterator>
+  unordered_set(InputIterator f, InputIterator l, const allocator_type& a);
+```
+
+Constructs an empty container using `a` as the allocator, with the default hash function and key equality predicate and a maximum load factor of `1.0` and inserts the elements from `[f, l)` into it.
+
+[horizontal]
+Requires:;; `hasher`, `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== Allocator Constructor
 ```c++
 explicit unordered_set(const Allocator& a);
@@ -523,6 +539,19 @@ Requires:;; `key_equal` needs to be https://en.cppreference.com/w/cpp/named_req/
 
 ---
 
+==== initializer_list Constructor with Allocator
+
+```c++
+unordered_set(std::initializer_list<value_type> il, const allocator_type& a);
+```
+
+Constructs an empty container using `a` as the allocator and a maximum load factor of 1.0 and inserts the elements from `il` into it.
+
+[horizontal]
+Requires:;; `hasher` and `key_equal` need to be https://en.cppreference.com/w/cpp/named_req/DefaultConstructible[DefaultConstructible^].
+
+---
+
 ==== initializer_list Constructor with Bucket Count and Allocator
 
 ```c++