diff --git a/include/boost/container/detail/iterator.hpp b/include/boost/container/detail/iterator.hpp
index 844f3fd..800cef3 100644
--- a/include/boost/container/detail/iterator.hpp
+++ b/include/boost/container/detail/iterator.hpp
@@ -69,6 +69,9 @@ class back_emplacer
 template<class InputIterator>
 using it_based_non_const_first_type_t = typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type;
 
+template<class InputIterator>
+using it_based_const_first_type_t = const typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type;
+
 template<class InputIterator>
 using it_based_second_type_t = typename iterator_traits<InputIterator>::value_type::second_type;
 
diff --git a/include/boost/container/flat_map.hpp b/include/boost/container/flat_map.hpp
index 255d53d..736af1c 100644
--- a/include/boost/container/flat_map.hpp
+++ b/include/boost/container/flat_map.hpp
@@ -49,10 +49,6 @@
 #include <initializer_list>
 #endif
 
-#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
-#include <type_traits>
-#endif
-
 namespace boost {
 namespace container {
 
@@ -1593,16 +1589,16 @@ template < typename InputIterator, typename AllocatorOrCompare>
     flat_map(InputIterator, InputIterator, AllocatorOrCompare const&) ->
     flat_map< it_based_non_const_first_type_t<InputIterator>
             , it_based_second_type_t<InputIterator>
-            , std::conditional_t<                                                                                               // Compare
+            , typename dtl::if_c< // Compare
                 dtl::is_allocator<AllocatorOrCompare>::value
                 , std::less<it_based_non_const_first_type_t<InputIterator>>
                 , AllocatorOrCompare
-                >
-            , std::conditional_t<                                                                                               // Allocator
+            >::type
+            , typename dtl::if_c< // Allocator
                 dtl::is_allocator<AllocatorOrCompare>::value
                 , AllocatorOrCompare
                 , new_allocator<std::pair<it_based_non_const_first_type_t<InputIterator>, it_based_second_type_t<InputIterator>>>
-                >
+                >::type
             >;
 
 template < typename InputIterator, typename Compare, typename Allocator
@@ -1623,16 +1619,16 @@ template < typename InputIterator, typename AllocatorOrCompare>
 flat_map(ordered_unique_range_t, InputIterator, InputIterator, AllocatorOrCompare const&) ->
    flat_map< it_based_non_const_first_type_t<InputIterator>
            , it_based_second_type_t<InputIterator>
-           , std::conditional_t<                                                                                               // Compare
+           , typename dtl::if_c<   // Compare
                dtl::is_allocator<AllocatorOrCompare>::value
                , std::less<it_based_non_const_first_type_t<InputIterator>>
                , AllocatorOrCompare
-               >
-           , std::conditional_t<                                                                                               // Allocator
+               >::type
+           , typename dtl::if_c<   // Allocator
                dtl::is_allocator<AllocatorOrCompare>::value
                , AllocatorOrCompare
                , new_allocator<std::pair<it_based_non_const_first_type_t<InputIterator>, it_based_second_type_t<InputIterator>>>
-               >
+               >::type
            >;
 
 template < typename InputIterator, typename Compare, typename Allocator
@@ -2901,16 +2897,16 @@ template < typename InputIterator, typename AllocatorOrCompare>
 flat_multimap(InputIterator, InputIterator, AllocatorOrCompare const&) ->
    flat_multimap< it_based_non_const_first_type_t<InputIterator>
                 , it_based_second_type_t<InputIterator>
-                , std::conditional_t<                                                                                               // Compare
+                , typename dtl::if_c<   // Compare
                     dtl::is_allocator<AllocatorOrCompare>::value
                     , std::less<it_based_non_const_first_type_t<InputIterator>>
                     , AllocatorOrCompare
-                    >
-                , std::conditional_t<                                                                                               // Allocator
+                    >::type
+                , typename dtl::if_c<   // Allocator
                     dtl::is_allocator<AllocatorOrCompare>::value
                     , AllocatorOrCompare
                     , new_allocator<std::pair<it_based_non_const_first_type_t<InputIterator>, it_based_second_type_t<InputIterator>>>
-                    >
+                    >::type
                 >;
 
 template < typename InputIterator, typename Compare, typename Allocator
@@ -2931,16 +2927,16 @@ template < typename InputIterator, typename AllocatorOrCompare>
 flat_multimap(ordered_range_t, InputIterator, InputIterator, AllocatorOrCompare const&) ->
    flat_multimap< it_based_non_const_first_type_t<InputIterator>
                 , it_based_second_type_t<InputIterator>
-                , std::conditional_t<                                                                                               // Compare
+                , typename dtl::if_c<   // Compare
                     dtl::is_allocator<AllocatorOrCompare>::value
                     , std::less<it_based_non_const_first_type_t<InputIterator>>
                     , AllocatorOrCompare
-                    >
-                , std::conditional_t<                                                                                               // Allocator
+                    >::type
+                , typename dtl::if_c<   // Allocator
                     dtl::is_allocator<AllocatorOrCompare>::value
                     , AllocatorOrCompare
                     , new_allocator<std::pair<it_based_non_const_first_type_t<InputIterator>, it_based_second_type_t<InputIterator>>>
-                    >
+                    >::type
                 >;
 
 template < typename InputIterator, typename Compare, typename Allocator
diff --git a/include/boost/container/flat_set.hpp b/include/boost/container/flat_set.hpp
index bd0b3cf..080beb5 100644
--- a/include/boost/container/flat_set.hpp
+++ b/include/boost/container/flat_set.hpp
@@ -1130,18 +1130,20 @@ template <typename InputIterator>
 flat_set(InputIterator, InputIterator) ->
    flat_set< it_based_value_type_t<InputIterator> >;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-flat_set(InputIterator, InputIterator, Allocator const&) ->
-   flat_set< it_based_value_type_t<InputIterator>
-           , std::less<it_based_value_type_t<InputIterator>>
-           , Allocator>;
-
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-flat_set(InputIterator, InputIterator, Compare const&) ->
-   flat_set< it_based_value_type_t<InputIterator>
-           , Compare>;
+template < typename InputIterator, typename AllocatorOrCompare>
+    flat_set(InputIterator, InputIterator, AllocatorOrCompare const&) ->
+    flat_set< it_based_value_type_t<InputIterator>
+            , typename dtl::if_c< // Compare
+                dtl::is_allocator<AllocatorOrCompare>::value
+                , std::less<it_based_value_type_t<InputIterator>>
+                , AllocatorOrCompare
+            >::type
+            , typename dtl::if_c< // Allocator
+                dtl::is_allocator<AllocatorOrCompare>::value
+                , AllocatorOrCompare
+                , new_allocator<it_based_value_type_t<InputIterator>>
+                >::type
+            >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
@@ -1155,18 +1157,21 @@ template <typename InputIterator>
 flat_set(ordered_unique_range_t, InputIterator, InputIterator) ->
    flat_set< it_based_value_type_t<InputIterator>>;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-flat_set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
-   flat_set< it_based_value_type_t<InputIterator>
-           , std::less<it_based_value_type_t<InputIterator>>
-           , Allocator>;
 
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-flat_set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
-   flat_set< it_based_value_type_t<InputIterator>
-           , Compare>;
+template < typename InputIterator, typename AllocatorOrCompare>
+    flat_set(ordered_unique_range_t, InputIterator, InputIterator, AllocatorOrCompare const&) ->
+    flat_set< it_based_value_type_t<InputIterator>
+            , typename dtl::if_c< // Compare
+                dtl::is_allocator<AllocatorOrCompare>::value
+                , std::less<it_based_value_type_t<InputIterator>>
+                , AllocatorOrCompare
+            >::type
+            , typename dtl::if_c< // Allocator
+                dtl::is_allocator<AllocatorOrCompare>::value
+                , AllocatorOrCompare
+                , new_allocator<it_based_value_type_t<InputIterator>>
+                >::type
+            >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
@@ -1859,18 +1864,21 @@ template <typename InputIterator>
 flat_multiset(InputIterator, InputIterator) ->
    flat_multiset< it_based_value_type_t<InputIterator> >;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-flat_multiset(InputIterator, InputIterator, Allocator const&) ->
-   flat_multiset< it_based_value_type_t<InputIterator>
-           , std::less<it_based_value_type_t<InputIterator>>
-           , Allocator>;
 
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-flat_multiset(InputIterator, InputIterator, Compare const&) ->
-   flat_multiset< it_based_value_type_t<InputIterator>
-           , Compare>;
+template < typename InputIterator, typename AllocatorOrCompare>
+flat_multiset(InputIterator, InputIterator, AllocatorOrCompare const&) ->
+    flat_multiset < it_based_value_type_t<InputIterator>
+                  , typename dtl::if_c< // Compare
+                      dtl::is_allocator<AllocatorOrCompare>::value
+                      , std::less<it_based_value_type_t<InputIterator>>
+                      , AllocatorOrCompare
+                  >::type
+                  , typename dtl::if_c< // Allocator
+                      dtl::is_allocator<AllocatorOrCompare>::value
+                      , AllocatorOrCompare
+                      , new_allocator<it_based_value_type_t<InputIterator>>
+                      >::type
+                  >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
@@ -1884,18 +1892,20 @@ template <typename InputIterator>
 flat_multiset(ordered_range_t, InputIterator, InputIterator) ->
    flat_multiset< it_based_value_type_t<InputIterator>>;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-flat_multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
-   flat_multiset< it_based_value_type_t<InputIterator>
-           , std::less<it_based_value_type_t<InputIterator>>
-           , Allocator>;
-
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-flat_multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
-   flat_multiset< it_based_value_type_t<InputIterator>
-           , Compare>;
+template < typename InputIterator, typename AllocatorOrCompare>
+flat_multiset(ordered_range_t, InputIterator, InputIterator, AllocatorOrCompare const&) ->
+    flat_multiset < it_based_value_type_t<InputIterator>
+                  , typename dtl::if_c< // Compare
+                      dtl::is_allocator<AllocatorOrCompare>::value
+                      , std::less<it_based_value_type_t<InputIterator>>
+                      , AllocatorOrCompare
+                  >::type
+                  , typename dtl::if_c< // Allocator
+                      dtl::is_allocator<AllocatorOrCompare>::value
+                      , AllocatorOrCompare
+                      , new_allocator<it_based_value_type_t<InputIterator>>
+                      >::type
+                  >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
diff --git a/include/boost/container/map.hpp b/include/boost/container/map.hpp
index 98109ad..8592c2c 100644
--- a/include/boost/container/map.hpp
+++ b/include/boost/container/map.hpp
@@ -1302,20 +1302,21 @@ map(InputIterator, InputIterator) ->
    map< it_based_non_const_first_type_t<InputIterator>
            , it_based_second_type_t<InputIterator>>;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-map(InputIterator, InputIterator, Allocator const&) ->
-   map< it_based_non_const_first_type_t<InputIterator>
-           , it_based_second_type_t<InputIterator>
-           , std::less<it_based_non_const_first_type_t<InputIterator>>
-           , Allocator>;
-
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-map(InputIterator, InputIterator, Compare const&) ->
-   map< it_based_non_const_first_type_t<InputIterator>
-           , it_based_second_type_t<InputIterator>
-           , Compare>;
+template < typename InputIterator, typename AllocatorOrCompare>
+    map(InputIterator, InputIterator, AllocatorOrCompare const&) ->
+    map< it_based_non_const_first_type_t<InputIterator>
+            , it_based_second_type_t<InputIterator>
+            , typename dtl::if_c< // Compare
+                dtl::is_allocator<AllocatorOrCompare>::value
+                , std::less<it_based_non_const_first_type_t<InputIterator>>
+                , AllocatorOrCompare
+            >::type
+            , typename dtl::if_c< // Allocator
+                dtl::is_allocator<AllocatorOrCompare>::value
+                , AllocatorOrCompare
+                , new_allocator<std::pair<it_based_const_first_type_t<InputIterator>, it_based_second_type_t<InputIterator>>>
+                >::type
+            >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
@@ -1331,20 +1332,21 @@ map(ordered_unique_range_t, InputIterator, InputIterator) ->
    map< it_based_non_const_first_type_t<InputIterator>
            , it_based_second_type_t<InputIterator>>;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-map(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
+template < typename InputIterator, typename AllocatorOrCompare>
+map(ordered_unique_range_t, InputIterator, InputIterator, AllocatorOrCompare const&) ->
    map< it_based_non_const_first_type_t<InputIterator>
            , it_based_second_type_t<InputIterator>
-           , std::less<it_based_non_const_first_type_t<InputIterator>>
-           , Allocator>;
-
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
-   map< it_based_non_const_first_type_t<InputIterator>
-           , it_based_second_type_t<InputIterator>
-           , Compare>;
+           , typename dtl::if_c<   // Compare
+               dtl::is_allocator<AllocatorOrCompare>::value
+               , std::less<it_based_non_const_first_type_t<InputIterator>>
+               , AllocatorOrCompare
+               >::type
+           , typename dtl::if_c<   // Allocator
+               dtl::is_allocator<AllocatorOrCompare>::value
+               , AllocatorOrCompare
+               , new_allocator<std::pair<it_based_const_first_type_t<InputIterator>, it_based_second_type_t<InputIterator>>>
+               >::type
+           >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
@@ -2229,20 +2231,21 @@ multimap(InputIterator, InputIterator) ->
    multimap< it_based_non_const_first_type_t<InputIterator>
            , it_based_second_type_t<InputIterator>>;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-multimap(InputIterator, InputIterator, Allocator const&) ->
+template < typename InputIterator, typename AllocatorOrCompare>
+multimap(InputIterator, InputIterator, AllocatorOrCompare const&) ->
    multimap< it_based_non_const_first_type_t<InputIterator>
-           , it_based_second_type_t<InputIterator>
-           , std::less<it_based_non_const_first_type_t<InputIterator>>
-           , Allocator>;
-
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-multimap(InputIterator, InputIterator, Compare const&) ->
-   multimap< it_based_non_const_first_type_t<InputIterator>
-           , it_based_second_type_t<InputIterator>
-           , Compare>;
+                , it_based_second_type_t<InputIterator>
+                , typename dtl::if_c<   // Compare
+                    dtl::is_allocator<AllocatorOrCompare>::value
+                    , std::less<it_based_non_const_first_type_t<InputIterator>>
+                    , AllocatorOrCompare
+                    >::type
+                , typename dtl::if_c<   // Allocator
+                    dtl::is_allocator<AllocatorOrCompare>::value
+                    , AllocatorOrCompare
+                    , new_allocator<std::pair<it_based_const_first_type_t<InputIterator>, it_based_second_type_t<InputIterator>>>
+                    >::type
+                >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
@@ -2258,20 +2261,21 @@ multimap(ordered_range_t, InputIterator, InputIterator) ->
    multimap< it_based_non_const_first_type_t<InputIterator>
            , it_based_second_type_t<InputIterator>>;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-multimap(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
+template < typename InputIterator, typename AllocatorOrCompare>
+multimap(ordered_range_t, InputIterator, InputIterator, AllocatorOrCompare const&) ->
    multimap< it_based_non_const_first_type_t<InputIterator>
-           , it_based_second_type_t<InputIterator>
-           , std::less<it_based_non_const_first_type_t<InputIterator>>
-           , Allocator>;
-
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-multimap(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
-   multimap< it_based_non_const_first_type_t<InputIterator>
-           , it_based_second_type_t<InputIterator>
-           , Compare>;
+                , it_based_second_type_t<InputIterator>
+                , typename dtl::if_c<   // Compare
+                    dtl::is_allocator<AllocatorOrCompare>::value
+                    , std::less<it_based_const_first_type_t<InputIterator>>
+                    , AllocatorOrCompare
+                    >::type
+                , typename dtl::if_c<   // Allocator
+                    dtl::is_allocator<AllocatorOrCompare>::value
+                    , AllocatorOrCompare
+                    , new_allocator<std::pair<it_based_const_first_type_t<InputIterator>, it_based_second_type_t<InputIterator>>>
+                    >::type
+                >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
diff --git a/include/boost/container/set.hpp b/include/boost/container/set.hpp
index c985c7e..8f9f58d 100644
--- a/include/boost/container/set.hpp
+++ b/include/boost/container/set.hpp
@@ -965,18 +965,20 @@ template <typename InputIterator>
 set(InputIterator, InputIterator) ->
    set< it_based_value_type_t<InputIterator> >;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-set(InputIterator, InputIterator, Allocator const&) ->
-   set< it_based_value_type_t<InputIterator>
-           , std::less<it_based_value_type_t<InputIterator>>
-           , Allocator>;
-
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-set(InputIterator, InputIterator, Compare const&) ->
-   set< it_based_value_type_t<InputIterator>
-           , Compare>;
+template < typename InputIterator, typename AllocatorOrCompare>
+    set(InputIterator, InputIterator, AllocatorOrCompare const&) ->
+    set< it_based_value_type_t<InputIterator>
+            , typename dtl::if_c< // Compare
+                dtl::is_allocator<AllocatorOrCompare>::value
+                , std::less<it_based_value_type_t<InputIterator>>
+                , AllocatorOrCompare
+            >::type
+            , typename dtl::if_c< // Allocator
+                dtl::is_allocator<AllocatorOrCompare>::value
+                , AllocatorOrCompare
+                , new_allocator<it_based_value_type_t<InputIterator>>
+                >::type
+            >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
@@ -990,18 +992,21 @@ template <typename InputIterator>
 set(ordered_unique_range_t, InputIterator, InputIterator) ->
    set< it_based_value_type_t<InputIterator>>;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-set(ordered_unique_range_t, InputIterator, InputIterator, Allocator const&) ->
-   set< it_based_value_type_t<InputIterator>
-           , std::less<it_based_value_type_t<InputIterator>>
-           , Allocator>;
 
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-set(ordered_unique_range_t, InputIterator, InputIterator, Compare const&) ->
-   set< it_based_value_type_t<InputIterator>
-           , Compare>;
+template < typename InputIterator, typename AllocatorOrCompare>
+    set(ordered_unique_range_t, InputIterator, InputIterator, AllocatorOrCompare const&) ->
+    set< it_based_value_type_t<InputIterator>
+            , typename dtl::if_c< // Compare
+                dtl::is_allocator<AllocatorOrCompare>::value
+                , std::less<it_based_value_type_t<InputIterator>>
+                , AllocatorOrCompare
+            >::type
+            , typename dtl::if_c< // Allocator
+                dtl::is_allocator<AllocatorOrCompare>::value
+                , AllocatorOrCompare
+                , new_allocator<it_based_value_type_t<InputIterator>>
+                >::type
+            >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
@@ -1626,18 +1631,21 @@ template <typename InputIterator>
 multiset(InputIterator, InputIterator) ->
    multiset< it_based_value_type_t<InputIterator> >;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-multiset(InputIterator, InputIterator, Allocator const&) ->
-   multiset< it_based_value_type_t<InputIterator>
-           , std::less<it_based_value_type_t<InputIterator>>
-           , Allocator>;
 
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-multiset(InputIterator, InputIterator, Compare const&) ->
-   multiset< it_based_value_type_t<InputIterator>
-           , Compare>;
+template < typename InputIterator, typename AllocatorOrCompare>
+multiset(InputIterator, InputIterator, AllocatorOrCompare const&) ->
+    multiset < it_based_value_type_t<InputIterator>
+                  , typename dtl::if_c< // Compare
+                      dtl::is_allocator<AllocatorOrCompare>::value
+                      , std::less<it_based_value_type_t<InputIterator>>
+                      , AllocatorOrCompare
+                  >::type
+                  , typename dtl::if_c< // Allocator
+                      dtl::is_allocator<AllocatorOrCompare>::value
+                      , AllocatorOrCompare
+                      , new_allocator<it_based_value_type_t<InputIterator>>
+                      >::type
+                  >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>
@@ -1651,18 +1659,20 @@ template <typename InputIterator>
 multiset(ordered_range_t, InputIterator, InputIterator) ->
    multiset< it_based_value_type_t<InputIterator>>;
 
-template < typename InputIterator, typename Allocator
-         , typename = dtl::require_allocator_t<Allocator>>
-multiset(ordered_range_t, InputIterator, InputIterator, Allocator const&) ->
-   multiset< it_based_value_type_t<InputIterator>
-           , std::less<it_based_value_type_t<InputIterator>>
-           , Allocator>;
-
-template < typename InputIterator, typename Compare
-         , typename = dtl::require_nonallocator_t<Compare>>
-multiset(ordered_range_t, InputIterator, InputIterator, Compare const&) ->
-   multiset< it_based_value_type_t<InputIterator>
-           , Compare>;
+template < typename InputIterator, typename AllocatorOrCompare>
+multiset(ordered_range_t, InputIterator, InputIterator, AllocatorOrCompare const&) ->
+    multiset < it_based_value_type_t<InputIterator>
+                  , typename dtl::if_c< // Compare
+                      dtl::is_allocator<AllocatorOrCompare>::value
+                      , std::less<it_based_value_type_t<InputIterator>>
+                      , AllocatorOrCompare
+                  >::type
+                  , typename dtl::if_c< // Allocator
+                      dtl::is_allocator<AllocatorOrCompare>::value
+                      , AllocatorOrCompare
+                      , new_allocator<it_based_value_type_t<InputIterator>>
+                      >::type
+                  >;
 
 template < typename InputIterator, typename Compare, typename Allocator
          , typename = dtl::require_nonallocator_t<Compare>