passenger 5.3.3 → 5.3.4

data/src/cxx_supportlib/vendor-modified/boost/container/detail/type_traits.hpp

@@ -28,7 +28,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 using ::boost::move_detail::enable_if;
 using ::boost::move_detail::enable_if_and;
@@ -63,7 +63,7 @@ using ::boost::move_detail::aligned_storage;
 using ::boost::move_detail::nat;
 using ::boost::move_detail::max_align_t;
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/container/detail/value_functors.hpp

@@ -0,0 +1,36 @@
+#ifndef BOOST_CONTAINER_DETAIL_VALUE_FUNCTORS_HPP
+#define BOOST_CONTAINER_DETAIL_VALUE_FUNCTORS_HPP
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2017. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+//Functors for member algorithm defaults
+template<class ValueType>
+struct value_less
+{
+   bool operator()(const ValueType &a, const ValueType &b) const
+      {  return a < b;  }
+};
+
+template<class ValueType>
+struct value_equal
+{
+   bool operator()(const ValueType &a, const ValueType &b) const
+      {  return a == b;  }
+};
+
+#endif   //BOOST_CONTAINER_DETAIL_VALUE_FUNCTORS_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/detail/value_init.hpp

@@ -26,7 +26,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class T>
 struct value_init
@@ -42,7 +42,7 @@ struct value_init
    T m_t;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/container/detail/variadic_templates_tools.hpp

@@ -28,7 +28,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<typename... Values>
 class tuple;
@@ -156,7 +156,7 @@ struct build_number_seq
 template<> struct build_number_seq<0> : index_tuple<>{};
 template<> struct build_number_seq<1> : index_tuple<0>{};
 
-}}}   //namespace boost { namespace container { namespace container_detail {
+}}}   //namespace boost { namespace container { namespace dtl {
 
 #include <boost/container/detail/config_end.hpp>
 

data/src/cxx_supportlib/vendor-modified/boost/container/detail/version_type.hpp

@@ -32,11 +32,11 @@
 
 namespace boost{
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template <class T, unsigned V>
 struct version_type
-    : public container_detail::integral_constant<unsigned, V>
+    : public dtl::integral_constant<unsigned, V>
 {
     typedef T type;
 
@@ -46,7 +46,7 @@ struct version_type
 namespace impl{
 
 template <class T,
-          bool = container_detail::is_convertible<version_type<T, 0>, typename T::version>::value>
+          bool = dtl::is_convertible<version_type<T, 0>, typename T::version>::value>
 struct extract_version
 {
    static const unsigned value = 1;
@@ -86,7 +86,7 @@ struct version<T, true>
 
 template <class T>
 struct version
-   : public container_detail::integral_constant<unsigned, impl::version<T>::value>
+   : public dtl::integral_constant<unsigned, impl::version<T>::value>
 {};
 
 template<class T, unsigned N>
@@ -96,11 +96,11 @@ struct is_version
       is_same< typename version<T>::type, integral_constant<unsigned, N> >::value;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
-typedef container_detail::integral_constant<unsigned, 0> version_0;
-typedef container_detail::integral_constant<unsigned, 1> version_1;
-typedef container_detail::integral_constant<unsigned, 2> version_2;
+typedef dtl::integral_constant<unsigned, 0> version_0;
+typedef dtl::integral_constant<unsigned, 1> version_1;
+typedef dtl::integral_constant<unsigned, 2> version_2;
 
 }  //namespace container {
 }  //namespace boost{

data/src/cxx_supportlib/vendor-modified/boost/container/detail/workaround.hpp

@@ -43,12 +43,6 @@
 #  endif
 #endif
 
-#if !defined(BOOST_FALLTHOUGH)
-   #define BOOST_CONTAINER_FALLTHOUGH
-#else
-   #define BOOST_CONTAINER_FALLTHOUGH BOOST_FALLTHOUGH;
-#endif
-
 #if defined(BOOST_MSVC) && (_MSC_VER < 1400)
    #define BOOST_CONTAINER_TEMPLATED_CONVERSION_OPERATOR_BROKEN
 #endif

data/src/cxx_supportlib/vendor-modified/boost/container/flat_map.hpp

@@ -30,6 +30,7 @@
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/algorithm.hpp> //equal()
+#include <boost/container/detail/container_or_allocator_rebind.hpp>
 // move
 #include <boost/move/utility_core.hpp>
 #include <boost/move/traits.hpp>
@@ -53,59 +54,60 @@ namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-template <class Key, class T, class Compare, class Allocator>
+template <class Key, class T, class Compare, class AllocatorOrContainer>
 class flat_multimap;
 
-namespace container_detail{
+namespace dtl{
 
 template<class D, class S>
-BOOST_CONTAINER_FORCEINLINE static D &force(const S &s)
-{  return *const_cast<D*>((reinterpret_cast<const D*>(&s))); }
+BOOST_CONTAINER_FORCEINLINE static D &force(S &s)
+{  return *reinterpret_cast<D*>(&s); }
 
 template<class D, class S>
-BOOST_CONTAINER_FORCEINLINE static D force_copy(S s)
+BOOST_CONTAINER_FORCEINLINE static D force_copy(const S &s)
 {
-   D *vp = reinterpret_cast<D *>(&s);
-   return D(*vp);
+   const D *const vp = reinterpret_cast<const D *>(&s);
+   D ret_val(*vp);
+   return ret_val;
 }
 
-}  //namespace container_detail{
+}  //namespace dtl{
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 //! A flat_map is a kind of associative container that supports unique keys (contains at
 //! most one of each key value) and provides for fast retrieval of values of another
-//! type T based on the keys. The flat_map class supports random-access iterators.
+//! type T based on the keys.
 //!
-//! A flat_map satisfies all of the requirements of a container and of a reversible
-//! container and of an associative container. A flat_map also provides
+//! A flat_map satisfies all of the requirements of a container, a reversible
+//! container and an associative container. A flat_map also provides
 //! most operations described for unique keys. For a
 //! flat_map<Key,T> the key_type is Key and the value_type is std::pair<Key,T>
 //! (unlike std::map<Key, T> which value_type is std::pair<<b>const</b> Key, T>).
 //!
-//! Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>).
+//! flat_map is similar to std::map but it's implemented by as an ordered sequence container.
+//! The underlying sequence container is by default <i>vector</i> but it can also work
+//! user-provided vector-like SequenceContainers (like <i>static_vector</i> or <i>small_vector</i>).
 //!
-//! Allocator is the allocator to allocate the value_types
-//! (e.g. <i>allocator< std::pair<Key, T> ></i>).
-//!
-//! flat_map is similar to std::map but it's implemented like an ordered vector.
-//! This means that inserting a new element into a flat_map invalidates
-//! previous iterators and references
-//!
-//! Erasing an element invalidates iterators and references
-//! pointing to elements that come after (their keys are bigger) the erased element.
+//! Using vector-like sequence containers means that inserting a new element into a flat_map might invalidate
+//! previous iterators and references (unless that sequence container is <i>stable_vector</i> or a similar
+//! container that offers stable pointers and references). Similarly, erasing an element might invalidate
+//! iterators and references pointing to elements that come after (their keys are bigger) the erased element.
 //!
 //! This container provides random-access iterators.
 //!
 //! \tparam Key is the key_type of the map
 //! \tparam Value is the <code>mapped_type</code>
 //! \tparam Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>).
-//! \tparam Allocator is the allocator to allocate the <code>value_type</code>s
-//!   (e.g. <i>allocator< std::pair<Key, T> > </i>).
+//! \tparam AllocatorOrContainer is either:
+//!   - The allocator to allocate <code>value_type</code>s (e.g. <i>allocator< std::pair<Key, T> > </i>).
+//!     (in this case <i>sequence_type</i> will be vector<value_type, AllocatorOrContainer>)
+//!   - The SequenceContainer to be used as the underlying <i>sequence_type</i>. It must be a vector-like
+//!     sequence container with random-access iterators..
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class Key, class T, class Compare = std::less<Key>, class Allocator = new_allocator< std::pair< Key, T> > >
+template <class Key, class T, class Compare = std::less<Key>, class AllocatorOrContainer = new_allocator< std::pair< Key, T> > >
 #else
-template <class Key, class T, class Compare, class Allocator>
+template <class Key, class T, class Compare, class AllocatorOrContainer>
 #endif
 class flat_map
 {
@@ -113,47 +115,54 @@ class flat_map
    private:
    BOOST_COPYABLE_AND_MOVABLE(flat_map)
    //This is the tree that we should store if pair was movable
-   typedef container_detail::flat_tree<
+   typedef dtl::flat_tree<
                            std::pair<Key, T>,
-                           container_detail::select1st<Key>,
+                           dtl::select1st<Key>,
                            Compare,
-                           Allocator> tree_t;
+                           AllocatorOrContainer> tree_t;
 
    //This is the real tree stored here. It's based on a movable pair
-   typedef container_detail::flat_tree<
-                           container_detail::pair<Key, T>,
-                           container_detail::select1st<Key>,
+   typedef dtl::flat_tree<
+                           dtl::pair<Key, T>,
+                           dtl::select1st<Key>,
                            Compare,
-                           typename allocator_traits<Allocator>::template portable_rebind_alloc
-                              <container_detail::pair<Key, T> >::type> impl_tree_t;
+                           typename dtl::container_or_allocator_rebind<AllocatorOrContainer, dtl::pair<Key, T> >::type
+                           > impl_tree_t;
    impl_tree_t m_flat_tree;  // flat tree representing flat_map
 
    typedef typename impl_tree_t::value_type              impl_value_type;
    typedef typename impl_tree_t::const_iterator          impl_const_iterator;
    typedef typename impl_tree_t::iterator                impl_iterator;
    typedef typename impl_tree_t::allocator_type          impl_allocator_type;
-   typedef container_detail::flat_tree_value_compare
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   typedef std::initializer_list<impl_value_type>        impl_initializer_list;
+   #endif
+
+   typedef dtl::flat_tree_value_compare
       < Compare
-      , container_detail::select1st<Key>
-      , std::pair<Key, T> >                                                         value_compare_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::iterator                  iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-      <typename allocator_traits<Allocator>::pointer>::const_iterator               const_iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::reverse_iterator          reverse_iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::const_reverse_iterator    const_reverse_iterator_impl;
+      , dtl::select1st<Key>
+      , std::pair<Key, T> >                              value_compare_t;
+   typedef typename tree_t::iterator                     iterator_t;
+   typedef typename tree_t::const_iterator               const_iterator_t;
+   typedef typename tree_t::reverse_iterator             reverse_iterator_t;
+   typedef typename tree_t::const_reverse_iterator       const_reverse_iterator_t;
+
    public:
    typedef typename impl_tree_t::stored_allocator_type   impl_stored_allocator_type;
+   typedef typename impl_tree_t::sequence_type           impl_sequence_type;
 
-   impl_tree_t &tree()
+   BOOST_CONTAINER_FORCEINLINE impl_tree_t &tree()
    {  return m_flat_tree;  }
 
-   const impl_tree_t &tree() const
+   BOOST_CONTAINER_FORCEINLINE const impl_tree_t &tree() const
    {  return m_flat_tree;  }
 
    private:
+   typedef typename tree_t::get_stored_allocator_const_return_t         get_stored_allocator_const_return_t;
+   typedef typename tree_t::get_stored_allocator_noconst_return_t       get_stored_allocator_noconst_return_t;
+   typedef typename impl_tree_t::get_stored_allocator_const_return_t    impl_get_stored_allocator_const_return_t;
+   typedef typename impl_tree_t::get_stored_allocator_noconst_return_t  impl_get_stored_allocator_noconst_return_t;
+
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
@@ -165,25 +174,29 @@ class flat_map
    //////////////////////////////////////////////
    typedef Key                                                                      key_type;
    typedef T                                                                        mapped_type;
-   typedef std::pair<Key, T>                                                        value_type;
-   typedef ::boost::container::allocator_traits<Allocator>                          allocator_traits_type;
-   typedef typename boost::container::allocator_traits<Allocator>::pointer          pointer;
-   typedef typename boost::container::allocator_traits<Allocator>::const_pointer    const_pointer;
-   typedef typename boost::container::allocator_traits<Allocator>::reference        reference;
-   typedef typename boost::container::allocator_traits<Allocator>::const_reference  const_reference;
-   typedef typename boost::container::allocator_traits<Allocator>::size_type        size_type;
-   typedef typename boost::container::allocator_traits<Allocator>::difference_type  difference_type;
-   typedef Allocator                                                                allocator_type;
-   typedef BOOST_CONTAINER_IMPDEF(Allocator)                                        stored_allocator_type;
-   typedef BOOST_CONTAINER_IMPDEF(value_compare_impl)                               value_compare;
    typedef Compare                                                                  key_compare;
-   typedef BOOST_CONTAINER_IMPDEF(iterator_impl)                                    iterator;
-   typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl)                              const_iterator;
-   typedef BOOST_CONTAINER_IMPDEF(reverse_iterator_impl)                            reverse_iterator;
-   typedef BOOST_CONTAINER_IMPDEF(const_reverse_iterator_impl)                      const_reverse_iterator;
+   typedef std::pair<Key, T>                                                        value_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::sequence_type)                   sequence_type;
+   typedef typename sequence_type::allocator_type                                   allocator_type;
+   typedef ::boost::container::allocator_traits<allocator_type>                     allocator_traits_type;
+   typedef typename sequence_type::pointer                                          pointer;
+   typedef typename sequence_type::const_pointer                                    const_pointer;
+   typedef typename sequence_type::reference                                        reference;
+   typedef typename sequence_type::const_reference                                  const_reference;
+   typedef typename sequence_type::size_type                                        size_type;
+   typedef typename sequence_type::difference_type                                  difference_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type)           stored_allocator_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::value_compare)                   value_compare;
+
+   typedef typename sequence_type::iterator                                         iterator;
+   typedef typename sequence_type::const_iterator                                   const_iterator;
+   typedef typename sequence_type::reverse_iterator                                 reverse_iterator;
+   typedef typename sequence_type::const_reverse_iterator                           const_reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF(impl_value_type)                                  movable_value_type;
 
-   public:
+   //AllocatorOrContainer::value_type must be std::pair<Key, T>
+   BOOST_STATIC_ASSERT((dtl::is_same<std::pair<Key, T>, typename allocator_type::value_type>::value));
+
    //////////////////////////////////////////////
    //
    //          construct/copy/destroy
@@ -193,106 +206,200 @@ class flat_map
    //! <b>Effects</b>: Default constructs an empty flat_map.
    //!
    //! <b>Complexity</b>: Constant.
-   flat_map()  BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                 container_detail::is_nothrow_default_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE flat_map() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<AllocatorOrContainer>::value &&
+                                                            dtl::is_nothrow_default_constructible<Compare>::value)
       : m_flat_tree()
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified allocator.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit flat_map(const allocator_type& a)
+      : m_flat_tree(dtl::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
-   //! comparison object and allocator.
+   //! comparison object.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_map(const Compare& comp, const allocator_type& a = allocator_type())
-      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE explicit flat_map(const Compare& comp)
+      : m_flat_tree(comp)
+   {}
 
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified allocator.
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified
+   //! comparison object and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_map(const allocator_type& a)
-      : m_flat_tree(container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(const Compare& comp, const allocator_type& a)
+      : m_flat_tree(comp, dtl::force<const impl_allocator_type>(a))
+   {}
 
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty flat_map and
+   //! and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_map(InputIterator first, InputIterator last, const Compare& comp = Compare(),
-         const allocator_type& a = allocator_type())
-      : m_flat_tree(true, first, last, comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last)
+      : m_flat_tree(true, first, last)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_map(InputIterator first, InputIterator last, const allocator_type& a)
-      : m_flat_tree(true, first, last, Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last, const allocator_type& a)
+      : m_flat_tree(true, first, last, dtl::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(true, first, last, comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the ordered unique range [first ,last). This function
+   //! allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_flat_tree(true, first, last, comp, dtl::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map
+   //! and inserts elements from the ordered range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
-   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
-   //! unique values.
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
    //!
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_map( ordered_unique_range_t, InputIterator first, InputIterator last
-           , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : m_flat_tree(ordered_unique_range, first, last, comp, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last)
+      : m_flat_tree(ordered_range, first, last)
+   {}
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin() ,il.end()).
+   //! inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(ordered_range, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_flat_tree(ordered_range, first, last, comp, dtl::force<const impl_allocator_type>(a))
+   {}
+
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   //! <b>Effects</b>: Constructs an empty flat_map and
+   //! inserts elements from the range [il.begin() ,il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
-   flat_map(std::initializer_list<value_type> il, const Compare& comp = Compare(),
-          const allocator_type& a = allocator_type())
-     : m_flat_tree(true, il.begin(), il.end(), comp, container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il)
+     : m_flat_tree( true
+                  , dtl::force<impl_initializer_list>(il).begin()
+                  , dtl::force<impl_initializer_list>(il).end())
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! allocator, and inserts elements from the range [il.begin() ,il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
-   flat_map(std::initializer_list<value_type> il, const allocator_type& a)
-     : m_flat_tree(true, il.begin(), il.end(), Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il, const allocator_type& a)
+     : m_flat_tree( true
+                  , dtl::force<impl_initializer_list>(il).begin()
+                  , dtl::force<impl_initializer_list>(il).end()
+                  , dtl::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the range [il.begin() ,il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il, const Compare& comp)
+     : m_flat_tree(true
+                  , dtl::force<impl_initializer_list>(il).begin()
+                  , dtl::force<impl_initializer_list>(il).end()
+                  , comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin() ,il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+     : m_flat_tree(true
+                  , dtl::force<impl_initializer_list>(il).begin()
+                  , dtl::force<impl_initializer_list>(il).end()
+                  , comp
+                  , dtl::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_map(ordered_unique_range_t, std::initializer_list<value_type> il)
+     : m_flat_tree(ordered_unique_range
+                  , dtl::force<impl_initializer_list>(il).begin()
+                  , dtl::force<impl_initializer_list>(il).end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
+     : m_flat_tree(ordered_unique_range
+                  , dtl::force<impl_initializer_list>(il).begin()
+                  , dtl::force<impl_initializer_list>(il).end()
+                  , comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [il.begin(), il.end()). This function
@@ -304,24 +411,21 @@ class flat_map
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(),
-          const allocator_type& a = allocator_type())
-     : m_flat_tree(ordered_unique_range, il.begin(), il.end(), comp, a)
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+     : m_flat_tree( ordered_unique_range
+                  , dtl::force<impl_initializer_list>(il).begin()
+                  , dtl::force<impl_initializer_list>(il).end()
+                  , comp
+                  , dtl::force<const impl_allocator_type>(a))
+   {}
 #endif
 
    //! <b>Effects</b>: Copy constructs a flat_map.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_map(const flat_map& x)
+   BOOST_CONTAINER_FORCEINLINE flat_map(const flat_map& x)
       : m_flat_tree(x.m_flat_tree)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_map.
    //!   Constructs *this using x's resources.
@@ -329,39 +433,30 @@ class flat_map
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   flat_map(BOOST_RV_REF(flat_map) x)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE flat_map(BOOST_RV_REF(flat_map) x)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       : m_flat_tree(boost::move(x.m_flat_tree))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Copy constructs a flat_map using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_map(const flat_map& x, const allocator_type &a)
-      : m_flat_tree(x.m_flat_tree, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(const flat_map& x, const allocator_type &a)
+      : m_flat_tree(x.m_flat_tree, dtl::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_map using the specified allocator.
    //!   Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if x.get_allocator() == a, linear otherwise.
-   flat_map(BOOST_RV_REF(flat_map) x, const allocator_type &a)
-      : m_flat_tree(boost::move(x.m_flat_tree), a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(BOOST_RV_REF(flat_map) x, const allocator_type &a)
+      : m_flat_tree(boost::move(x.m_flat_tree), dtl::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_map& operator=(BOOST_COPY_ASSIGN_REF(flat_map) x)
+   BOOST_CONTAINER_FORCEINLINE flat_map& operator=(BOOST_COPY_ASSIGN_REF(flat_map) x)
    {  m_flat_tree = x.m_flat_tree;   return *this;  }
 
    //! <b>Effects</b>: Move constructs a flat_map.
@@ -373,10 +468,10 @@ class flat_map
    //! <b>Complexity</b>: Constant if allocator_traits_type::
    //!   propagate_on_container_move_assignment is true or
    //!   this->get>allocator() == x.get_allocator(). Linear otherwise.
-   flat_map& operator=(BOOST_RV_REF(flat_map) x)
+   BOOST_CONTAINER_FORCEINLINE flat_map& operator=(BOOST_RV_REF(flat_map) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
-                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
+                           boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {  m_flat_tree = boost::move(x.m_flat_tree);   return *this;  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -393,8 +488,8 @@ class flat_map
    //!   was passed to the object's constructor.
    //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
+   BOOST_CONTAINER_FORCEINLINE allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
    //!
@@ -403,8 +498,11 @@ class flat_map
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
-   stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+   BOOST_CONTAINER_FORCEINLINE get_stored_allocator_noconst_return_t get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      impl_get_stored_allocator_noconst_return_t r = m_flat_tree.get_stored_allocator();
+      return dtl::force<stored_allocator_type>(r);
+   }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
    //!
@@ -413,8 +511,11 @@ class flat_map
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
-   const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+   BOOST_CONTAINER_FORCEINLINE get_stored_allocator_const_return_t get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      impl_get_stored_allocator_const_return_t r = m_flat_tree.get_stored_allocator();
+      return dtl::force<const stored_allocator_type>(r);
+   }
 
    //////////////////////////////////////////////
    //
@@ -427,32 +528,32 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<iterator>(m_flat_tree.begin()); }
+   BOOST_CONTAINER_FORCEINLINE iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_iterator>(m_flat_tree.begin()); }
+   BOOST_CONTAINER_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<const_iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   iterator end() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<iterator>(m_flat_tree.end()); }
+   BOOST_CONTAINER_FORCEINLINE iterator end() BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<iterator>(m_flat_tree.end()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_iterator>(m_flat_tree.end()); }
+   BOOST_CONTAINER_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<const_iterator>(m_flat_tree.end()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
    //! of the reversed container.
@@ -460,8 +561,8 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }
+   BOOST_CONTAINER_FORCEINLINE reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
    //! of the reversed container.
@@ -469,8 +570,8 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
    //! of the reversed container.
@@ -478,8 +579,8 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rend()); }
+   BOOST_CONTAINER_FORCEINLINE reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
    //! of the reversed container.
@@ -487,24 +588,24 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_iterator>(m_flat_tree.cbegin()); }
+   BOOST_CONTAINER_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<const_iterator>(m_flat_tree.cbegin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_iterator>(m_flat_tree.cend()); }
+   BOOST_CONTAINER_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<const_iterator>(m_flat_tree.cend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
    //! of the reversed container.
@@ -512,8 +613,8 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
    //! of the reversed container.
@@ -521,8 +622,8 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }
 
    //////////////////////////////////////////////
    //
@@ -535,7 +636,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
@@ -543,7 +644,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
@@ -551,7 +652,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.max_size(); }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
@@ -560,10 +661,11 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.capacity(); }
 
-   //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
+   //! <b>Effects</b>: If n is less than or equal to capacity(), or the
+   //!   underlying container has no `reserve` member, this call has no
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
@@ -572,7 +674,7 @@ class flat_map
    //!
    //! <b>Note</b>: If capacity() is less than "cnt", iterators and references to
    //!   to values might be invalidated.
-   void reserve(size_type cnt)
+   BOOST_CONTAINER_FORCEINLINE void reserve(size_type cnt)
       { m_flat_tree.reserve(cnt);   }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
@@ -581,7 +683,7 @@ class flat_map
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to size().
-   void shrink_to_fit()
+   BOOST_CONTAINER_FORCEINLINE void shrink_to_fit()
       { m_flat_tree.shrink_to_fit(); }
 
    //////////////////////////////////////////////
@@ -608,8 +710,8 @@ class flat_map
    mapped_type &operator[](key_type &&k) ;
    #elif defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
       //in compilers like GCC 3.4, we can't catch temporaries
-      mapped_type& operator[](const key_type &k)         {  return this->priv_subscript(k);  }
-      mapped_type& operator[](BOOST_RV_REF(key_type) k)  {  return this->priv_subscript(::boost::move(k));  }
+      BOOST_CONTAINER_FORCEINLINE mapped_type& operator[](const key_type &k)         {  return this->priv_subscript(k);  }
+      BOOST_CONTAINER_FORCEINLINE mapped_type& operator[](BOOST_RV_REF(key_type) k)  {  return this->priv_subscript(::boost::move(k));  }
    #else
       BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, this->priv_subscript)
    #endif
@@ -629,7 +731,7 @@ class flat_map
    template <class M>
    BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> insert_or_assign(const key_type& k, BOOST_FWD_REF(M) obj)
    {
-      return container_detail::force_copy< std::pair<iterator, bool> >
+      return dtl::force_copy< std::pair<iterator, bool> >
          (this->m_flat_tree.insert_or_assign
             ( impl_const_iterator(), k, ::boost::forward<M>(obj))
          );
@@ -650,7 +752,7 @@ class flat_map
    template <class M>
    BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> insert_or_assign(BOOST_RV_REF(key_type) k, BOOST_FWD_REF(M) obj)
    {
-      return container_detail::force_copy< std::pair<iterator, bool> >
+      return dtl::force_copy< std::pair<iterator, bool> >
          (this->m_flat_tree.insert_or_assign
             ( impl_const_iterator(), ::boost::move(k), ::boost::forward<M>(obj))
          );
@@ -673,9 +775,9 @@ class flat_map
    template <class M>
    BOOST_CONTAINER_FORCEINLINE iterator insert_or_assign(const_iterator hint, const key_type& k, BOOST_FWD_REF(M) obj)
    {
-      return container_detail::force_copy< std::pair<iterator, bool> >
+      return dtl::force_copy< std::pair<iterator, bool> >
          (this->m_flat_tree.insert_or_assign
-            ( container_detail::force_copy<impl_const_iterator>(hint)
+            ( dtl::force_copy<impl_const_iterator>(hint)
             , k, ::boost::forward<M>(obj))
          );
    }
@@ -697,28 +799,28 @@ class flat_map
    template <class M>
    BOOST_CONTAINER_FORCEINLINE iterator insert_or_assign(const_iterator hint, BOOST_RV_REF(key_type) k, BOOST_FWD_REF(M) obj)
    {
-      return container_detail::force_copy< std::pair<iterator, bool> >
+      return dtl::force_copy< std::pair<iterator, bool> >
          (this->m_flat_tree.insert_or_assign
-            ( container_detail::force_copy<impl_const_iterator>(hint)
+            ( dtl::force_copy<impl_const_iterator>(hint)
             , ::boost::move(k), ::boost::forward<M>(obj))
          );
    }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type)
-   iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
+   BOOST_CONTAINER_FORCEINLINE iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   {  return dtl::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type) const
-   const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
+   BOOST_CONTAINER_FORCEINLINE const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+   {  return dtl::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(iterator)
-   size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return m_flat_tree.index_of(container_detail::force_copy<impl_iterator>(p));  }
+   BOOST_CONTAINER_FORCEINLINE size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
+   {  return m_flat_tree.index_of(dtl::force_copy<impl_iterator>(p));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(const_iterator) const
-   size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return m_flat_tree.index_of(container_detail::force_copy<impl_const_iterator>(p));  }
+   BOOST_CONTAINER_FORCEINLINE size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
+   {  return m_flat_tree.index_of(dtl::force_copy<impl_const_iterator>(p));  }
 
    //! Returns: A reference to the element whose key is equivalent to x.
    //!
@@ -769,8 +871,8 @@ class flat_map
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
-   {  return container_detail::force_copy< std::pair<iterator, bool> >(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
+   {  return dtl::force_copy< std::pair<iterator, bool> >(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
 
    //! <b>Effects</b>: Inserts an object of type T constructed with
    //!   std::forward<Args>(args)... in the container if and only if there is
@@ -785,10 +887,10 @@ class flat_map
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {
-      return container_detail::force_copy<iterator>
-         (m_flat_tree.emplace_hint_unique( container_detail::force_copy<impl_const_iterator>(hint)
+      return dtl::force_copy<iterator>
+         (m_flat_tree.emplace_hint_unique( dtl::force_copy<impl_const_iterator>(hint)
                                          , boost::forward<Args>(args)...));
    }
 
@@ -806,7 +908,7 @@ class flat_map
    template <class... Args>
    BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> try_emplace(const key_type& k, BOOST_FWD_REF(Args)... args)
    {
-      return container_detail::force_copy< std::pair<iterator, bool> >(
+      return dtl::force_copy< std::pair<iterator, bool> >(
          m_flat_tree.try_emplace(impl_const_iterator(), k, boost::forward<Args>(args)...));
    }
 
@@ -824,8 +926,8 @@ class flat_map
    template <class... Args>
    BOOST_CONTAINER_FORCEINLINE iterator try_emplace(const_iterator hint, const key_type &k, BOOST_FWD_REF(Args)... args)
    {
-      return container_detail::force_copy<iterator>(m_flat_tree.try_emplace
-         (container_detail::force_copy<impl_const_iterator>(hint), k, boost::forward<Args>(args)...).first);
+      return dtl::force_copy<iterator>(m_flat_tree.try_emplace
+         (dtl::force_copy<impl_const_iterator>(hint), k, boost::forward<Args>(args)...).first);
    }
 
    //! <b>Requires</b>: value_type shall be EmplaceConstructible into map from piecewise_construct, 
@@ -842,7 +944,7 @@ class flat_map
    template <class... Args>
    BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> try_emplace(BOOST_RV_REF(key_type) k, BOOST_FWD_REF(Args)... args)
    {
-      return container_detail::force_copy< std::pair<iterator, bool> >
+      return dtl::force_copy< std::pair<iterator, bool> >
          (m_flat_tree.try_emplace(impl_const_iterator(), boost::move(k), boost::forward<Args>(args)...));
    }
 
@@ -860,8 +962,8 @@ class flat_map
    template <class... Args>
    BOOST_CONTAINER_FORCEINLINE iterator try_emplace(const_iterator hint, BOOST_RV_REF(key_type) k, BOOST_FWD_REF(Args)... args)
    {
-      return container_detail::force_copy<iterator>
-         (m_flat_tree.try_emplace(container_detail::force_copy
+      return dtl::force_copy<iterator>
+         (m_flat_tree.try_emplace(dtl::force_copy
             <impl_const_iterator>(hint), boost::move(k), boost::forward<Args>(args)...).first);
    }
 
@@ -869,41 +971,41 @@ class flat_map
 
    #define BOOST_CONTAINER_FLAT_MAP_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
    {\
-      return container_detail::force_copy< std::pair<iterator, bool> >\
+      return dtl::force_copy< std::pair<iterator, bool> >\
          (m_flat_tree.emplace_unique(BOOST_MOVE_FWD##N));\
    }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
-      return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_unique\
-         (container_detail::force_copy<impl_const_iterator>(hint) BOOST_MOVE_I##N BOOST_MOVE_FWD##N));\
+      return dtl::force_copy<iterator>(m_flat_tree.emplace_hint_unique\
+         (dtl::force_copy<impl_const_iterator>(hint) BOOST_MOVE_I##N BOOST_MOVE_FWD##N));\
    }\
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
    BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> try_emplace(const key_type& k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
-      return container_detail::force_copy< std::pair<iterator, bool> >\
+      return dtl::force_copy< std::pair<iterator, bool> >\
          (m_flat_tree.try_emplace(impl_const_iterator(), k BOOST_MOVE_I##N BOOST_MOVE_FWD##N));\
    }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
    BOOST_CONTAINER_FORCEINLINE iterator try_emplace(const_iterator hint, const key_type &k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
-   {  return container_detail::force_copy<iterator>(m_flat_tree.try_emplace\
-         (container_detail::force_copy<impl_const_iterator>(hint), k BOOST_MOVE_I##N BOOST_MOVE_FWD##N).first); }\
+   {  return dtl::force_copy<iterator>(m_flat_tree.try_emplace\
+         (dtl::force_copy<impl_const_iterator>(hint), k BOOST_MOVE_I##N BOOST_MOVE_FWD##N).first); }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
    BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> try_emplace(BOOST_RV_REF(key_type) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
-      return container_detail::force_copy< std::pair<iterator, bool> >\
+      return dtl::force_copy< std::pair<iterator, bool> >\
          (m_flat_tree.try_emplace(impl_const_iterator(), boost::move(k) BOOST_MOVE_I##N BOOST_MOVE_FWD##N));\
    }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
    BOOST_CONTAINER_FORCEINLINE iterator try_emplace(const_iterator hint, BOOST_RV_REF(key_type) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
-   {  return container_detail::force_copy<iterator>(m_flat_tree.try_emplace\
-      (container_detail::force_copy<impl_const_iterator>(hint), boost::move(k) BOOST_MOVE_I##N BOOST_MOVE_FWD##N).first); }\
+   {  return dtl::force_copy<iterator>(m_flat_tree.try_emplace\
+      (dtl::force_copy<impl_const_iterator>(hint), boost::move(k) BOOST_MOVE_I##N BOOST_MOVE_FWD##N).first); }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_FLAT_MAP_EMPLACE_CODE)
    #undef BOOST_CONTAINER_FLAT_MAP_EMPLACE_CODE
@@ -921,9 +1023,9 @@ class flat_map
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(const value_type& x)
-   {  return container_detail::force_copy<std::pair<iterator,bool> >(
-         m_flat_tree.insert_unique(container_detail::force<impl_value_type>(x))); }
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> insert(const value_type& x)
+   {  return dtl::force_copy<std::pair<iterator,bool> >(
+         m_flat_tree.insert_unique(dtl::force<const impl_value_type>(x))); }
 
    //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
    //! only if there is no element in the container with key equivalent to the key of x.
@@ -936,9 +1038,9 @@ class flat_map
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
-   {  return container_detail::force_copy<std::pair<iterator,bool> >(
-      m_flat_tree.insert_unique(boost::move(container_detail::force<impl_value_type>(x)))); }
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+   {  return dtl::force_copy<std::pair<iterator,bool> >(
+      m_flat_tree.insert_unique(boost::move(dtl::force<impl_value_type>(x)))); }
 
    //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
    //! only if there is no element in the container with key equivalent to the key of x.
@@ -951,9 +1053,9 @@ class flat_map
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x)
    {
-      return container_detail::force_copy<std::pair<iterator,bool> >
+      return dtl::force_copy<std::pair<iterator,bool> >
       (m_flat_tree.insert_unique(boost::move(x)));
    }
 
@@ -968,11 +1070,11 @@ class flat_map
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, const value_type& x)
    {
-      return container_detail::force_copy<iterator>(
-         m_flat_tree.insert_unique( container_detail::force_copy<impl_const_iterator>(p)
-                                  , container_detail::force<impl_value_type>(x)));
+      return dtl::force_copy<iterator>(
+         m_flat_tree.insert_unique( dtl::force_copy<impl_const_iterator>(p)
+                                  , dtl::force<const impl_value_type>(x)));
    }
 
    //! <b>Effects</b>: Inserts an element move constructed from x in the container.
@@ -984,11 +1086,11 @@ class flat_map
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    {
-      return container_detail::force_copy<iterator>
-         (m_flat_tree.insert_unique( container_detail::force_copy<impl_const_iterator>(p)
-                                   , boost::move(container_detail::force<impl_value_type>(x))));
+      return dtl::force_copy<iterator>
+         (m_flat_tree.insert_unique( dtl::force_copy<impl_const_iterator>(p)
+                                   , boost::move(dtl::force<impl_value_type>(x))));
    }
 
    //! <b>Effects</b>: Inserts an element move constructed from x in the container.
@@ -1000,10 +1102,10 @@ class flat_map
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x)
    {
-      return container_detail::force_copy<iterator>(
-         m_flat_tree.insert_unique(container_detail::force_copy<impl_const_iterator>(p), boost::move(x)));
+      return dtl::force_copy<iterator>(
+         m_flat_tree.insert_unique(dtl::force_copy<impl_const_iterator>(p), boost::move(x)));
    }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -1011,12 +1113,11 @@ class flat_map
    //! <b>Effects</b>: inserts each element from the range [first,last) if and only
    //!   if there is no element with key equivalent to the key of that element.
    //!
-   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
-   //!   search time plus N*size() insertion time.
+   //! <b>Complexity</b>: N log(size()+N).
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
    {  m_flat_tree.insert_unique(first, last);  }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -1028,26 +1129,27 @@ class flat_map
    //!   if there is no element with key equivalent to the key of that element. This
    //!   function is more efficient than the normal range creation for ordered ranges.
    //!
-   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
-   //!   search time plus N*size() insertion time.
+   //! <b>Complexity</b>: Linear.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
       {  m_flat_tree.insert_unique(ordered_unique_range, first, last); }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end()) if and only
    //!   if there is no element with key equivalent to the key of that element.
    //!
-   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from il.first() to il.end())
-   //!   search time plus N*size() insertion time.
+   //! <b>Complexity</b>: N log(N).
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   void insert(std::initializer_list<value_type> il)
-   {  m_flat_tree.insert_unique(il.begin(), il.end());  }
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
+   {
+      m_flat_tree.insert_unique( dtl::force<impl_initializer_list>(il).begin()
+                               , dtl::force<impl_initializer_list>(il).end());
+   }
 
    //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
    //! unique values.
@@ -1056,14 +1158,17 @@ class flat_map
    //!   if there is no element with key equivalent to the key of that element. This
    //!   function is more efficient than the normal range creation for ordered ranges.
    //!
-   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
-   //!   search time plus N*size() insertion time.
+   //! <b>Complexity</b>: Linear.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    //!
    //! <b>Note</b>: Non-standard extension.
-   void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
-   {  m_flat_tree.insert_unique(ordered_unique_range, il.begin(), il.end()); }
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
+   {
+      m_flat_tree.insert_unique(ordered_unique_range
+                               , dtl::force<impl_initializer_list>(il).begin()
+                               , dtl::force<impl_initializer_list>(il).end());
+   }
 #endif
 
    //! <b>Requires</b>: this->get_allocator() == source.get_allocator().
@@ -1081,23 +1186,23 @@ class flat_map
    //!
    //! <b>Complexity</b>: N log(a.size() + N) (N has the value source.size())
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(flat_map<Key, T, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_map<Key, T, C2, AllocatorOrContainer>& source)
    {  m_flat_tree.merge_unique(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_map<Key, T, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_map<Key, T, C2, Allocator>&>(source)); }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_map<Key, T, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_map<Key, T, C2, AllocatorOrContainer>&>(source)); }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(flat_multimap<Key, T, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_multimap<Key, T, C2, AllocatorOrContainer>& source)
    {  m_flat_tree.merge_unique(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multimap<Key, T, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_multimap<Key, T, C2, Allocator>&>(source));  }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multimap<Key, T, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_multimap<Key, T, C2, AllocatorOrContainer>&>(source));  }
 
    //! <b>Effects</b>: Erases the element pointed to by p.
    //!
@@ -1109,10 +1214,10 @@ class flat_map
    //!
    //! <b>Note</b>: Invalidates elements with keys
    //!   not less than the erased element.
-   iterator erase(const_iterator p)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator p)
    {
-      return container_detail::force_copy<iterator>
-         (m_flat_tree.erase(container_detail::force_copy<impl_const_iterator>(p)));
+      return dtl::force_copy<iterator>
+         (m_flat_tree.erase(dtl::force_copy<impl_const_iterator>(p)));
    }
 
    //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
@@ -1121,7 +1226,7 @@ class flat_map
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
       { return m_flat_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -1132,11 +1237,11 @@ class flat_map
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   iterator erase(const_iterator first, const_iterator last)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
    {
-      return container_detail::force_copy<iterator>(
-         m_flat_tree.erase( container_detail::force_copy<impl_const_iterator>(first)
-                          , container_detail::force_copy<impl_const_iterator>(last)));
+      return dtl::force_copy<iterator>(
+         m_flat_tree.erase( dtl::force_copy<impl_const_iterator>(first)
+                          , dtl::force_copy<impl_const_iterator>(last)));
    }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
@@ -1144,9 +1249,9 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   void swap(flat_map& x)
+   BOOST_CONTAINER_FORCEINLINE void swap(flat_map& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_swappable<Compare>::value )
+                                 && boost::container::dtl::is_nothrow_swappable<Compare>::value )
    { m_flat_tree.swap(x.m_flat_tree); }
 
    //! <b>Effects</b>: erase(a.begin(),a.end()).
@@ -1154,7 +1259,7 @@ class flat_map
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void clear() BOOST_NOEXCEPT_OR_NOTHROW
       { m_flat_tree.clear(); }
 
    //////////////////////////////////////////////
@@ -1167,15 +1272,15 @@ class flat_map
    //!   of which a was constructed.
    //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const
-      { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }
+   BOOST_CONTAINER_FORCEINLINE key_compare key_comp() const
+      { return dtl::force_copy<key_compare>(m_flat_tree.key_comp()); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
    //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const
-      { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }
+   BOOST_CONTAINER_FORCEINLINE value_compare value_comp() const
+      { return value_compare(dtl::force_copy<key_compare>(m_flat_tree.key_comp())); }
 
    //////////////////////////////////////////////
    //
@@ -1187,102 +1292,135 @@ class flat_map
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x)
-      { return container_detail::force_copy<iterator>(m_flat_tree.find(x)); }
+   BOOST_CONTAINER_FORCEINLINE iterator find(const key_type& x)
+      { return dtl::force_copy<iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: A const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const
-      { return container_detail::force_copy<const_iterator>(m_flat_tree.find(x)); }
+   BOOST_CONTAINER_FORCEINLINE const_iterator find(const key_type& x) const
+      { return dtl::force_copy<const_iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x) const
       {  return static_cast<size_type>(m_flat_tree.find(x) != m_flat_tree.end());  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator lower_bound(const key_type& x)
-      {  return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
+   BOOST_CONTAINER_FORCEINLINE iterator lower_bound(const key_type& x)
+      {  return dtl::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator lower_bound(const key_type& x) const
-      {  return container_detail::force_copy<const_iterator>(m_flat_tree.lower_bound(x)); }
+   BOOST_CONTAINER_FORCEINLINE const_iterator lower_bound(const key_type& x) const
+      {  return dtl::force_copy<const_iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator upper_bound(const key_type& x)
-      {  return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }
+   BOOST_CONTAINER_FORCEINLINE iterator upper_bound(const key_type& x)
+      {  return dtl::force_copy<iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator upper_bound(const key_type& x) const
-      {  return container_detail::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }
+   BOOST_CONTAINER_FORCEINLINE const_iterator upper_bound(const key_type& x) const
+      {  return dtl::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<iterator,iterator> equal_range(const key_type& x)
-      {  return container_detail::force_copy<std::pair<iterator,iterator> >(m_flat_tree.lower_bound_range(x)); }
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
+      {  return dtl::force_copy<std::pair<iterator,iterator> >(m_flat_tree.lower_bound_range(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
-      {  return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.lower_bound_range(x)); }
+   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
+      {  return dtl::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.lower_bound_range(x)); }
+
+   //! <b>Effects</b>: Extracts the internal sequence container.
+   //!
+   //! <b>Complexity</b>: Same as the move constructor of sequence_type, usually constant.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   BOOST_CONTAINER_FORCEINLINE sequence_type extract_sequence()
+   {
+      return boost::move(dtl::force<sequence_type>(m_flat_tree.get_sequence_ref()));
+   }
+
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment. Erases non-unique elements.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()
+   //!
+   //! <b>Throws</b>: If the comparison or the move constructor throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_unique(boost::move(dtl::force<impl_sequence_type>(seq)));  }
+
+   //! <b>Requires</b>: seq shall be ordered according to this->compare()
+   //!   and shall contain unique elements.
+   //!
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(1)
+   //!
+   //! <b>Throws</b>: If the move assignment throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_unique_range_t, BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_unique(ordered_unique_range_t(), boost::move(dtl::force<impl_sequence_type>(seq)));  }
 
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator==(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator==(const flat_map& x, const flat_map& y)
    {  return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());  }
 
    //! <b>Effects</b>: Returns true if x and y are unequal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator!=(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const flat_map& x, const flat_map& y)
    {  return !(x == y); }
 
    //! <b>Effects</b>: Returns true if x is less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<(const flat_map& x, const flat_map& y)
    {  return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
 
    //! <b>Effects</b>: Returns true if x is greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>(const flat_map& x, const flat_map& y)
    {  return y < x;  }
 
    //! <b>Effects</b>: Returns true if x is equal or less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<=(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<=(const flat_map& x, const flat_map& y)
    {  return !(y < x);  }
 
    //! <b>Effects</b>: Returns true if x is equal or greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>=(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>=(const flat_map& x, const flat_map& y)
    {  return !(x < y);  }
 
    //! <b>Effects</b>: x.swap(y)
    //!
    //! <b>Complexity</b>: Constant.
-   friend void swap(flat_map& x, flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend void swap(flat_map& x, flat_map& y)
    {  x.swap(y);  }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -1292,7 +1430,7 @@ class flat_map
       iterator i = lower_bound(k);
       // i->first is greater than or equivalent to k.
       if (i == end() || key_comp()(k, (*i).first)){
-         container_detail::value_init<mapped_type> m;
+         dtl::value_init<mapped_type> m;
          i = insert(i, impl_value_type(k, ::boost::move(m.m_t)));
       }
       return (*i).second;
@@ -1303,7 +1441,7 @@ class flat_map
       iterator i = lower_bound(k);
       // i->first is greater than or equivalent to k.
       if (i == end() || key_comp()(k, (*i).first)){
-         container_detail::value_init<mapped_type> m;
+         dtl::value_init<mapped_type> m;
          i = insert(i, impl_value_type(boost::move(k), ::boost::move(m.m_t)));
       }
       return (*i).second;
@@ -1317,11 +1455,11 @@ class flat_map
 
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
-template <class Key, class T, class Compare, class Allocator>
-struct has_trivial_destructor_after_move<boost::container::flat_map<Key, T, Compare, Allocator> >
+template <class Key, class T, class Compare, class AllocatorOrContainer>
+struct has_trivial_destructor_after_move<boost::container::flat_map<Key, T, Compare, AllocatorOrContainer> >
 {
-   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+   typedef typename ::boost::container::allocator_traits<AllocatorOrContainer>::pointer pointer;
+   static const bool value = ::boost::has_trivial_destructor_after_move<AllocatorOrContainer>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value &&
                              ::boost::has_trivial_destructor_after_move<Compare>::value;
 };
@@ -1332,80 +1470,81 @@ namespace container {
 
 //! A flat_multimap is a kind of associative container that supports equivalent keys
 //! (possibly containing multiple copies of the same key value) and provides for
-//! fast retrieval of values of another type T based on the keys. The flat_multimap
-//! class supports random-access iterators.
+//! fast retrieval of values of another type T based on the keys. 
 //!
 //! A flat_multimap satisfies all of the requirements of a container and of a reversible
 //! container and of an associative container. For a
 //! flat_multimap<Key,T> the key_type is Key and the value_type is std::pair<Key,T>
 //! (unlike std::multimap<Key, T> which value_type is std::pair<<b>const</b> Key, T>).
 //!
-//! Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>).
+//! flat_multimap is similar to std::multimap but it's implemented by as an ordered sequence container.
+//! The underlying sequence container is by default <i>vector</i> but it can also work
+//! user-provided vector-like SequenceContainers (like <i>static_vector</i> or <i>small_vector</i>).
 //!
-//! Allocator is the allocator to allocate the value_types
-//! (e.g. <i>allocator< std::pair<Key, T> ></i>).
-//!
-//! flat_multimap is similar to std::multimap but it's implemented like an ordered vector.
-//! This means that inserting a new element into a flat_map invalidates
-//! previous iterators and references
-//!
-//! Erasing an element invalidates iterators and references
-//! pointing to elements that come after (their keys are bigger) the erased element.
+//! Using vector-like sequence containers means that inserting a new element into a flat_multimap might invalidate
+//! previous iterators and references (unless that sequence container is <i>stable_vector</i> or a similar
+//! container that offers stable pointers and references). Similarly, erasing an element might invalidate
+//! iterators and references pointing to elements that come after (their keys are bigger) the erased element.
 //!
 //! This container provides random-access iterators.
 //!
 //! \tparam Key is the key_type of the map
 //! \tparam Value is the <code>mapped_type</code>
 //! \tparam Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>).
-//! \tparam Allocator is the allocator to allocate the <code>value_type</code>s
-//!   (e.g. <i>allocator< std::pair<Key, T> > </i>).
+//! \tparam AllocatorOrContainer is either:
+//!   - The allocator to allocate <code>value_type</code>s (e.g. <i>allocator< std::pair<Key, T> > </i>).
+//!     (in this case <i>sequence_type</i> will be vector<value_type, AllocatorOrContainer>)
+//!   - The SequenceContainer to be used as the underlying <i>sequence_type</i>. It must be a vector-like
+//!     sequence container with random-access iterators.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class Key, class T, class Compare = std::less<Key>, class Allocator = new_allocator< std::pair< Key, T> > >
+template <class Key, class T, class Compare = std::less<Key>, class AllocatorOrContainer = new_allocator< std::pair< Key, T> > >
 #else
-template <class Key, class T, class Compare, class Allocator>
+template <class Key, class T, class Compare, class AllocatorOrContainer>
 #endif
 class flat_multimap
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    BOOST_COPYABLE_AND_MOVABLE(flat_multimap)
-   typedef container_detail::flat_tree<
+   typedef dtl::flat_tree<
                            std::pair<Key, T>,
-                           container_detail::select1st<Key>,
+                           dtl::select1st<Key>,
                            Compare,
-                           Allocator> tree_t;
+                           AllocatorOrContainer> tree_t;
    //This is the real tree stored here. It's based on a movable pair
-   typedef container_detail::flat_tree<
-                           container_detail::pair<Key, T>,
-                           container_detail::select1st<Key>,
+   typedef dtl::flat_tree<
+                           dtl::pair<Key, T>,
+                           dtl::select1st<Key>,
                            Compare,
-                           typename allocator_traits<Allocator>::template portable_rebind_alloc
-                              <container_detail::pair<Key, T> >::type> impl_tree_t;
+                           typename dtl::container_or_allocator_rebind<AllocatorOrContainer, dtl::pair<Key, T> >::type
+                           > impl_tree_t;
    impl_tree_t m_flat_tree;  // flat tree representing flat_map
 
    typedef typename impl_tree_t::value_type              impl_value_type;
    typedef typename impl_tree_t::const_iterator          impl_const_iterator;
    typedef typename impl_tree_t::iterator                impl_iterator;
    typedef typename impl_tree_t::allocator_type          impl_allocator_type;
-   typedef container_detail::flat_tree_value_compare
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   typedef std::initializer_list<impl_value_type>        impl_initializer_list;
+   #endif
+
+   typedef dtl::flat_tree_value_compare
       < Compare
-      , container_detail::select1st<Key>
-      , std::pair<Key, T> >                                                         value_compare_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::iterator                  iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-      <typename allocator_traits<Allocator>::pointer>::const_iterator               const_iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::reverse_iterator          reverse_iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::const_reverse_iterator    const_reverse_iterator_impl;
+      , dtl::select1st<Key>
+      , std::pair<Key, T> >                                 value_compare_t;
+   typedef typename tree_t::iterator                        iterator_t;
+   typedef typename tree_t::const_iterator                  const_iterator_t;
+   typedef typename tree_t::reverse_iterator                reverse_iterator_t;
+   typedef typename tree_t::const_reverse_iterator          const_reverse_iterator_t;
+
    public:
-   typedef typename impl_tree_t::stored_allocator_type   impl_stored_allocator_type;
+   typedef typename impl_tree_t::stored_allocator_type      impl_stored_allocator_type;
+   typedef typename impl_tree_t::sequence_type              impl_sequence_type;
 
-   impl_tree_t &tree()
+   BOOST_CONTAINER_FORCEINLINE impl_tree_t &tree()
    {  return m_flat_tree;  }
 
-   const impl_tree_t &tree() const
+   BOOST_CONTAINER_FORCEINLINE const impl_tree_t &tree() const
    {  return m_flat_tree;  }
 
    private:
@@ -1420,24 +1559,29 @@ class flat_multimap
    //////////////////////////////////////////////
    typedef Key                                                                      key_type;
    typedef T                                                                        mapped_type;
-   typedef std::pair<Key, T>                                                        value_type;
-   typedef ::boost::container::allocator_traits<Allocator>                          allocator_traits_type;
-   typedef typename boost::container::allocator_traits<Allocator>::pointer          pointer;
-   typedef typename boost::container::allocator_traits<Allocator>::const_pointer    const_pointer;
-   typedef typename boost::container::allocator_traits<Allocator>::reference        reference;
-   typedef typename boost::container::allocator_traits<Allocator>::const_reference  const_reference;
-   typedef typename boost::container::allocator_traits<Allocator>::size_type        size_type;
-   typedef typename boost::container::allocator_traits<Allocator>::difference_type  difference_type;
-   typedef Allocator                                                                allocator_type;
-   typedef BOOST_CONTAINER_IMPDEF(Allocator)                                        stored_allocator_type;
-   typedef BOOST_CONTAINER_IMPDEF(value_compare_impl)                               value_compare;
    typedef Compare                                                                  key_compare;
-   typedef BOOST_CONTAINER_IMPDEF(iterator_impl)                                    iterator;
-   typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl)                              const_iterator;
-   typedef BOOST_CONTAINER_IMPDEF(reverse_iterator_impl)                            reverse_iterator;
-   typedef BOOST_CONTAINER_IMPDEF(const_reverse_iterator_impl)                      const_reverse_iterator;
+   typedef std::pair<Key, T>                                                        value_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::sequence_type)                   sequence_type;
+   typedef typename sequence_type::allocator_type                                   allocator_type;
+   typedef ::boost::container::allocator_traits<allocator_type>                     allocator_traits_type;
+   typedef typename sequence_type::pointer                                          pointer;
+   typedef typename sequence_type::const_pointer                                    const_pointer;
+   typedef typename sequence_type::reference                                        reference;
+   typedef typename sequence_type::const_reference                                  const_reference;
+   typedef typename sequence_type::size_type                                        size_type;
+   typedef typename sequence_type::difference_type                                  difference_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type)           stored_allocator_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::value_compare)                   value_compare;
+
+   typedef typename sequence_type::iterator                                         iterator;
+   typedef typename sequence_type::const_iterator                                   const_iterator;
+   typedef typename sequence_type::reverse_iterator                                 reverse_iterator;
+   typedef typename sequence_type::const_reverse_iterator                           const_reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF(impl_value_type)                                  movable_value_type;
 
+   //AllocatorOrContainer::value_type must be std::pair<Key, T>
+   BOOST_STATIC_ASSERT((dtl::is_same<std::pair<Key, T>, typename AllocatorOrContainer::value_type>::value));
+
    //////////////////////////////////////////////
    //
    //          construct/copy/destroy
@@ -1447,63 +1591,109 @@ class flat_multimap
    //! <b>Effects</b>: Default constructs an empty flat_map.
    //!
    //! <b>Complexity</b>: Constant.
-   flat_multimap() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                     container_detail::is_nothrow_default_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE flat_multimap()
+      BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<AllocatorOrContainer>::value &&
+                        dtl::is_nothrow_default_constructible<Compare>::value)
       : m_flat_tree()
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified allocator.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multimap(const allocator_type& a)
+      : m_flat_tree(dtl::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison
-   //!   object and allocator.
+   //!   object .
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_multimap(const Compare& comp,
-                          const allocator_type& a = allocator_type())
-      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multimap(const Compare& comp)
+      : m_flat_tree(comp)
+   {}
 
-   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified allocator.
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison
+   //!   object and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_multimap(const allocator_type& a)
-      : m_flat_tree(container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(const Compare& comp, const allocator_type& a)
+      : m_flat_tree(comp, dtl::force<const impl_allocator_type>(a))
+   {}
 
-   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
-   //!   and allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty flat_multimap
+   //!   and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_multimap(InputIterator first, InputIterator last,
-            const Compare& comp        = Compare(),
-            const allocator_type& a = allocator_type())
-      : m_flat_tree(false, first, last, comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(InputIterator first, InputIterator last)
+      : m_flat_tree(false, first, last)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified
    //!   allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(InputIterator first, InputIterator last, const allocator_type& a)
-      : m_flat_tree(false, first, last, Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+      : m_flat_tree(false, first, last, dtl::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
+   //!   and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(false, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
+   //!   and allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_flat_tree(false, first, last, comp, dtl::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap
+   //! and inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, InputIterator first, InputIterator last)
+      : m_flat_tree(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(ordered_range, first, last, comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last). This function
@@ -1515,39 +1705,93 @@ class flat_multimap
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_multimap(ordered_range_t, InputIterator first, InputIterator last,
-            const Compare& comp        = Compare(),
-            const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : m_flat_tree(ordered_range, first, last, comp, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! <b>Effects</b>: Constructs an empty flat_map and
+   //! inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
-   flat_multimap(std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : m_flat_tree(false, il.begin(), il.end(), comp, container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(std::initializer_list<value_type> il)
+      : m_flat_tree( false
+                   , dtl::force<impl_initializer_list>(il).begin()
+                   , dtl::force<impl_initializer_list>(il).end())
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! allocator, and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(std::initializer_list<value_type> il, const allocator_type& a)
-      : m_flat_tree(false, il.begin(), il.end(), Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+      : m_flat_tree(false
+                   , dtl::force<impl_initializer_list>(il).begin()
+                   , dtl::force<impl_initializer_list>(il).end()
+                   , dtl::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(std::initializer_list<value_type> il, const Compare& comp)
+      : m_flat_tree(false
+                   , dtl::force<impl_initializer_list>(il).begin()
+                   , dtl::force<impl_initializer_list>(il).end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : m_flat_tree( false
+                   , dtl::force<impl_initializer_list>(il).begin()
+                   , dtl::force<impl_initializer_list>(il).end()
+                   , comp, dtl::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, std::initializer_list<value_type> il)
+      : m_flat_tree( ordered_range
+                   , dtl::force<impl_initializer_list>(il).begin()
+                   , dtl::force<impl_initializer_list>(il).end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : m_flat_tree( ordered_range
+                   , dtl::force<impl_initializer_list>(il).begin()
+                   , dtl::force<impl_initializer_list>(il).end(), comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [il.begin(), il.end()). This function
@@ -1558,78 +1802,73 @@ class flat_multimap
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(),
-                 const allocator_type& a = allocator_type())
-      : m_flat_tree(ordered_range, il.begin(), il.end(), comp, a)
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : m_flat_tree( ordered_range
+                   , dtl::force<impl_initializer_list>(il).begin()
+                   , dtl::force<impl_initializer_list>(il).end()
+                   , comp, dtl::force<const impl_allocator_type>(a))
+   {}
 #endif
 
    //! <b>Effects</b>: Copy constructs a flat_multimap.
    //!
    //! <b>Complexity</b>: Linear in x.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(const flat_multimap& x)
       : m_flat_tree(x.m_flat_tree)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_multimap. Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(BOOST_RV_REF(flat_multimap) x)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       : m_flat_tree(boost::move(x.m_flat_tree))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Copy constructs a flat_multimap using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(const flat_multimap& x, const allocator_type &a)
-      : m_flat_tree(x.m_flat_tree, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+      : m_flat_tree(x.m_flat_tree, dtl::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_multimap using the specified allocator.
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(BOOST_RV_REF(flat_multimap) x, const allocator_type &a)
-      : m_flat_tree(boost::move(x.m_flat_tree), a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+      : m_flat_tree(boost::move(x.m_flat_tree), dtl::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap& operator=(BOOST_COPY_ASSIGN_REF(flat_multimap) x)
       {  m_flat_tree = x.m_flat_tree;   return *this;  }
 
    //! <b>Effects</b>: this->swap(x.get()).
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap& operator=(BOOST_RV_REF(flat_multimap) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
-                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
+                           boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
       {  m_flat_tree = boost::move(x.m_flat_tree);   return *this;  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: Assign content of il to *this
    //!
    //! <b>Complexity</b>: Linear in il.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap& operator=(std::initializer_list<value_type> il)
    {
       this->clear();
@@ -1642,8 +1881,9 @@ class flat_multimap
    //!   was passed to the object's constructor.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
+      { return dtl::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
    //!
@@ -1652,8 +1892,9 @@ class flat_multimap
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
    stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+      { return dtl::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
    //!
@@ -1662,8 +1903,9 @@ class flat_multimap
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
    const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+      { return dtl::force<const stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
    //////////////////////////////////////////////
    //
@@ -1676,32 +1918,36 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<iterator>(m_flat_tree.begin()); }
+      { return dtl::force_copy<iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_iterator>(m_flat_tree.begin()); }
+      { return dtl::force_copy<const_iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    iterator end() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<iterator>(m_flat_tree.end()); }
+      { return dtl::force_copy<iterator>(m_flat_tree.end()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_iterator>(m_flat_tree.end()); }
+      { return dtl::force_copy<const_iterator>(m_flat_tree.end()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
    //! of the reversed container.
@@ -1709,8 +1955,9 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }
+      { return dtl::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
    //! of the reversed container.
@@ -1718,8 +1965,9 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }
+      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
    //! of the reversed container.
@@ -1727,8 +1975,9 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rend()); }
+      { return dtl::force_copy<reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
    //! of the reversed container.
@@ -1736,24 +1985,27 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }
+      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_iterator>(m_flat_tree.cbegin()); }
+      { return dtl::force_copy<const_iterator>(m_flat_tree.cbegin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_iterator>(m_flat_tree.cend()); }
+      { return dtl::force_copy<const_iterator>(m_flat_tree.cend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
    //! of the reversed container.
@@ -1761,8 +2013,9 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }
+      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
    //! of the reversed container.
@@ -1770,8 +2023,9 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }
+      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }
 
    //////////////////////////////////////////////
    //
@@ -1784,6 +2038,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.empty(); }
 
@@ -1792,6 +2047,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.size(); }
 
@@ -1800,6 +2056,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.max_size(); }
 
@@ -1809,10 +2066,12 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.capacity(); }
 
-   //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
+   //! <b>Effects</b>: If n is less than or equal to capacity(), or the
+   //!   underlying container has no `reserve` member, this call has no
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
@@ -1821,6 +2080,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: If capacity() is less than "cnt", iterators and references to
    //!   to values might be invalidated.
+   BOOST_CONTAINER_FORCEINLINE
    void reserve(size_type cnt)
       { m_flat_tree.reserve(cnt);   }
 
@@ -1830,24 +2090,29 @@ class flat_multimap
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to size().
+   BOOST_CONTAINER_FORCEINLINE
    void shrink_to_fit()
       { m_flat_tree.shrink_to_fit(); }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type)
+   BOOST_CONTAINER_FORCEINLINE
    iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
+   {  return dtl::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type) const
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
+   {  return dtl::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(iterator)
+   BOOST_CONTAINER_FORCEINLINE
    size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return m_flat_tree.index_of(container_detail::force_copy<impl_iterator>(p));  }
+   {  return m_flat_tree.index_of(dtl::force_copy<impl_iterator>(p));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(const_iterator) const
+   BOOST_CONTAINER_FORCEINLINE
    size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return m_flat_tree.index_of(container_detail::force_copy<impl_const_iterator>(p));  }
+   {  return m_flat_tree.index_of(dtl::force_copy<impl_const_iterator>(p));  }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
@@ -1860,8 +2125,9 @@ class flat_multimap
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
+   BOOST_CONTAINER_FORCEINLINE
    iterator emplace(BOOST_FWD_REF(Args)... args)
-   {  return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }
+   {  return dtl::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }
 
    //! <b>Effects</b>: Inserts an object of type T constructed with
    //!   std::forward<Args>(args)... in the container.
@@ -1876,24 +2142,25 @@ class flat_multimap
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
+   BOOST_CONTAINER_FORCEINLINE
    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {
-      return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal
-         (container_detail::force_copy<impl_const_iterator>(hint), boost::forward<Args>(args)...));
+      return dtl::force_copy<iterator>(m_flat_tree.emplace_hint_equal
+         (dtl::force_copy<impl_const_iterator>(hint), boost::forward<Args>(args)...));
    }
 
    #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #define BOOST_CONTAINER_FLAT_MULTIMAP_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace(BOOST_MOVE_UREF##N)\
-   {  return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal(BOOST_MOVE_FWD##N));  }\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_MOVE_UREF##N)\
+   {  return dtl::force_copy<iterator>(m_flat_tree.emplace_equal(BOOST_MOVE_FWD##N));  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
-      return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal\
-         (container_detail::force_copy<impl_const_iterator>(hint) BOOST_MOVE_I##N BOOST_MOVE_FWD##N));\
+      return dtl::force_copy<iterator>(m_flat_tree.emplace_hint_equal\
+         (dtl::force_copy<impl_const_iterator>(hint) BOOST_MOVE_I##N BOOST_MOVE_FWD##N));\
    }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_FLAT_MULTIMAP_EMPLACE_CODE)
@@ -1908,10 +2175,10 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const value_type& x)
    {
-      return container_detail::force_copy<iterator>(
-         m_flat_tree.insert_equal(container_detail::force<impl_value_type>(x)));
+      return dtl::force_copy<iterator>(
+         m_flat_tree.insert_equal(dtl::force<const impl_value_type>(x)));
    }
 
    //! <b>Effects</b>: Inserts a new value move-constructed from x and returns
@@ -1921,8 +2188,8 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(BOOST_RV_REF(value_type) x)
-   { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
+   BOOST_CONTAINER_FORCEINLINE iterator insert(BOOST_RV_REF(value_type) x)
+   { return dtl::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
 
    //! <b>Effects</b>: Inserts a new value move-constructed from x and returns
    //!   the iterator pointing to the newly inserted element.
@@ -1931,8 +2198,8 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(BOOST_RV_REF(impl_value_type) x)
-      { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
+   BOOST_CONTAINER_FORCEINLINE iterator insert(BOOST_RV_REF(impl_value_type) x)
+      { return dtl::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
 
    //! <b>Effects</b>: Inserts a copy of x in the container.
    //!   p is a hint pointing to where the insert should start to search.
@@ -1945,11 +2212,11 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, const value_type& x)
    {
-      return container_detail::force_copy<iterator>
-         (m_flat_tree.insert_equal( container_detail::force_copy<impl_const_iterator>(p)
-                                  , container_detail::force<impl_value_type>(x)));
+      return dtl::force_copy<iterator>
+         (m_flat_tree.insert_equal( dtl::force_copy<impl_const_iterator>(p)
+                                  , dtl::force<const impl_value_type>(x)));
    }
 
    //! <b>Effects</b>: Inserts a value move constructed from x in the container.
@@ -1963,10 +2230,10 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    {
-      return container_detail::force_copy<iterator>
-         (m_flat_tree.insert_equal(container_detail::force_copy<impl_const_iterator>(p)
+      return dtl::force_copy<iterator>
+         (m_flat_tree.insert_equal(dtl::force_copy<impl_const_iterator>(p)
                                   , boost::move(x)));
    }
 
@@ -1981,22 +2248,21 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(impl_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(impl_value_type) x)
    {
-      return container_detail::force_copy<iterator>(
-         m_flat_tree.insert_equal(container_detail::force_copy<impl_const_iterator>(p), boost::move(x)));
+      return dtl::force_copy<iterator>(
+         m_flat_tree.insert_equal(dtl::force_copy<impl_const_iterator>(p), boost::move(x)));
    }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
    //!
    //! <b>Effects</b>: inserts each element from the range [first,last) .
    //!
-   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
-   //!   search time plus N*size() insertion time.
+   //! <b>Complexity</b>: N log(N).
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
       {  m_flat_tree.insert_equal(first, last); }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -2007,25 +2273,26 @@ class flat_multimap
    //!   if there is no element with key equivalent to the key of that element. This
    //!   function is more efficient than the normal range creation for ordered ranges.
    //!
-   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
-   //!   search time plus N*size() insertion time.
+   //! <b>Complexity</b>: Linear.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   void insert(ordered_range_t, InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_range_t, InputIterator first, InputIterator last)
       {  m_flat_tree.insert_equal(ordered_range, first, last); }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end()) .
    //!
-   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
-   //!   search time plus N*size() insertion time.
+   //! <b>Complexity</b>: N log(N).
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   void insert(std::initializer_list<value_type> il)
-   {  m_flat_tree.insert_equal(il.begin(), il.end()); }
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
+   {
+      m_flat_tree.insert_equal( dtl::force<impl_initializer_list>(il).begin()
+                              , dtl::force<impl_initializer_list>(il).end());
+   }
 
    //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
    //!
@@ -2033,14 +2300,17 @@ class flat_multimap
    //!   if there is no element with key equivalent to the key of that element. This
    //!   function is more efficient than the normal range creation for ordered ranges.
    //!
-   //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
-   //!   search time plus N*size() insertion time.
+   //! <b>Complexity</b>: Linear.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    //!
    //! <b>Note</b>: Non-standard extension.
-   void insert(ordered_range_t, std::initializer_list<value_type> il)
-   {  m_flat_tree.insert_equal(ordered_range, il.begin(), il.end());  }
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_range_t, std::initializer_list<value_type> il)
+   {
+      m_flat_tree.insert_equal( ordered_range
+                              , dtl::force<impl_initializer_list>(il).begin()
+                              , dtl::force<impl_initializer_list>(il).end());
+   }
 #endif
 
    //! <b>Requires</b>: this->get_allocator() == source.get_allocator().
@@ -2057,23 +2327,23 @@ class flat_multimap
    //!
    //! <b>Complexity</b>: N log(a.size() + N) (N has the value source.size())
    template<class C2>
-   void merge(flat_multimap<Key, T, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_multimap<Key, T, C2, AllocatorOrContainer>& source)
    {  m_flat_tree.merge_equal(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   void merge(BOOST_RV_REF_BEG flat_multimap<Key, T, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_multimap<Key, T, C2, Allocator>&>(source)); }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multimap<Key, T, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_multimap<Key, T, C2, AllocatorOrContainer>&>(source)); }
 
-   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   void merge(flat_map<Key, T, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_map<Key, T, C2, AllocatorOrContainer>& source)
    {  m_flat_tree.merge_equal(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multimap::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   void merge(BOOST_RV_REF_BEG flat_map<Key, T, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_map<Key, T, C2, Allocator>&>(source)); }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_map<Key, T, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_map<Key, T, C2, AllocatorOrContainer>&>(source)); }
 
    //! <b>Effects</b>: Erases the element pointed to by p.
    //!
@@ -2085,10 +2355,10 @@ class flat_multimap
    //!
    //! <b>Note</b>: Invalidates elements with keys
    //!   not less than the erased element.
-   iterator erase(const_iterator p)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator p)
    {
-      return container_detail::force_copy<iterator>(
-         m_flat_tree.erase(container_detail::force_copy<impl_const_iterator>(p)));
+      return dtl::force_copy<iterator>(
+         m_flat_tree.erase(dtl::force_copy<impl_const_iterator>(p)));
    }
 
    //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
@@ -2097,7 +2367,7 @@ class flat_multimap
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
       { return m_flat_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -2108,11 +2378,11 @@ class flat_multimap
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   iterator erase(const_iterator first, const_iterator last)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
    {
-      return container_detail::force_copy<iterator>
-         (m_flat_tree.erase( container_detail::force_copy<impl_const_iterator>(first)
-                           , container_detail::force_copy<impl_const_iterator>(last)));
+      return dtl::force_copy<iterator>
+         (m_flat_tree.erase( dtl::force_copy<impl_const_iterator>(first)
+                           , dtl::force_copy<impl_const_iterator>(last)));
    }
 
    //! <b>Effects</b>: Swaps the contents of *this and x.
@@ -2120,9 +2390,9 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   void swap(flat_multimap& x)
+   BOOST_CONTAINER_FORCEINLINE void swap(flat_multimap& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_swappable<Compare>::value )
+                                 && boost::container::dtl::is_nothrow_swappable<Compare>::value )
    { m_flat_tree.swap(x.m_flat_tree); }
 
    //! <b>Effects</b>: erase(a.begin(),a.end()).
@@ -2130,7 +2400,7 @@ class flat_multimap
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void clear() BOOST_NOEXCEPT_OR_NOTHROW
       { m_flat_tree.clear(); }
 
    //////////////////////////////////////////////
@@ -2143,15 +2413,15 @@ class flat_multimap
    //!   of which a was constructed.
    //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const
-      { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }
+   BOOST_CONTAINER_FORCEINLINE key_compare key_comp() const
+      { return dtl::force_copy<key_compare>(m_flat_tree.key_comp()); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
    //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const
-      { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }
+   BOOST_CONTAINER_FORCEINLINE value_compare value_comp() const
+      { return value_compare(dtl::force_copy<key_compare>(m_flat_tree.key_comp())); }
 
    //////////////////////////////////////////////
    //
@@ -2163,102 +2433,134 @@ class flat_multimap
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x)
-      { return container_detail::force_copy<iterator>(m_flat_tree.find(x)); }
+   BOOST_CONTAINER_FORCEINLINE iterator find(const key_type& x)
+      { return dtl::force_copy<iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: An const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const
-      { return container_detail::force_copy<const_iterator>(m_flat_tree.find(x)); }
+   BOOST_CONTAINER_FORCEINLINE const_iterator find(const key_type& x) const
+      { return dtl::force_copy<const_iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x) const
       { return m_flat_tree.count(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x)
-      {  return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
+   BOOST_CONTAINER_FORCEINLINE iterator lower_bound(const key_type& x)
+      {  return dtl::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key
    //!   not less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const
-      {  return container_detail::force_copy<const_iterator>(m_flat_tree.lower_bound(x));  }
+   BOOST_CONTAINER_FORCEINLINE const_iterator lower_bound(const key_type& x) const
+      {  return dtl::force_copy<const_iterator>(m_flat_tree.lower_bound(x));  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator upper_bound(const key_type& x)
-      {return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }
+   BOOST_CONTAINER_FORCEINLINE iterator upper_bound(const key_type& x)
+      {return dtl::force_copy<iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key
    //!   not less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const
-      {  return container_detail::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }
+   BOOST_CONTAINER_FORCEINLINE const_iterator upper_bound(const key_type& x) const
+      {  return dtl::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x)
-      {  return container_detail::force_copy<std::pair<iterator,iterator> >(m_flat_tree.equal_range(x));   }
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
+      {  return dtl::force_copy<std::pair<iterator,iterator> >(m_flat_tree.equal_range(x));   }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
-      {  return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x));   }
+   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
+      {  return dtl::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x));   }
+
+   //! <b>Effects</b>: Extracts the internal sequence container.
+   //!
+   //! <b>Complexity</b>: Same as the move constructor of sequence_type, usually constant.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   BOOST_CONTAINER_FORCEINLINE sequence_type extract_sequence()
+   {
+      return boost::move(dtl::force<sequence_type>(m_flat_tree.get_sequence_ref()));
+   }
+
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()
+   //!
+   //! <b>Throws</b>: If the comparison or the move constructor throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_equal(boost::move(dtl::force<impl_sequence_type>(seq)));  }
+
+   //! <b>Requires</b>: seq shall be ordered according to this->compare().
+   //!
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(1)
+   //!
+   //! <b>Throws</b>: If the move assignment throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_range_t, BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_equal(ordered_range_t(), boost::move(dtl::force<impl_sequence_type>(seq)));  }
 
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator==(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator==(const flat_multimap& x, const flat_multimap& y)
    {  return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());  }
 
    //! <b>Effects</b>: Returns true if x and y are unequal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator!=(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const flat_multimap& x, const flat_multimap& y)
    {  return !(x == y); }
 
    //! <b>Effects</b>: Returns true if x is less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<(const flat_multimap& x, const flat_multimap& y)
    {  return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
 
    //! <b>Effects</b>: Returns true if x is greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>(const flat_multimap& x, const flat_multimap& y)
    {  return y < x;  }
 
    //! <b>Effects</b>: Returns true if x is equal or less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<=(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<=(const flat_multimap& x, const flat_multimap& y)
    {  return !(y < x);  }
 
    //! <b>Effects</b>: Returns true if x is equal or greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>=(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>=(const flat_multimap& x, const flat_multimap& y)
    {  return !(x < y);  }
 
    //! <b>Effects</b>: x.swap(y)
    //!
    //! <b>Complexity</b>: Constant.
-   friend void swap(flat_multimap& x, flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend void swap(flat_multimap& x, flat_multimap& y)
    {  x.swap(y);  }
 };
 
@@ -2270,11 +2572,11 @@ namespace boost {
 
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
-template <class Key, class T, class Compare, class Allocator>
-struct has_trivial_destructor_after_move< boost::container::flat_multimap<Key, T, Compare, Allocator> >
+template <class Key, class T, class Compare, class AllocatorOrContainer>
+struct has_trivial_destructor_after_move< boost::container::flat_multimap<Key, T, Compare, AllocatorOrContainer> >
 {
-   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+   typedef typename ::boost::container::allocator_traits<AllocatorOrContainer>::pointer pointer;
+   static const bool value = ::boost::has_trivial_destructor_after_move<AllocatorOrContainer>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value &&
                              ::boost::has_trivial_destructor_after_move<Compare>::value;
 };