passenger 6.1.0 → 6.1.1

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

@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2005-2015. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2025-2025. 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)
 //
@@ -38,8 +38,10 @@
 #include <boost/container/detail/mpl.hpp>
 #include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
+#include <boost/container/detail/math_functions.hpp>
 // move
 #include <boost/move/adl_move_swap.hpp>
+#include <boost/move/algo/detail/merge.hpp>
 #include <boost/move/iterator.hpp>
 #include <boost/move/traits.hpp>
 #include <boost/move/utility_core.hpp>
@@ -61,8 +63,6 @@ namespace boost {
 namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class T, class Allocator, class Options>
-class deque;
 
 template <class T>
 struct deque_value_traits
@@ -72,468 +72,56 @@ struct deque_value_traits
    BOOST_STATIC_CONSTEXPR bool trivial_dctr_after_move = ::boost::has_trivial_destructor_after_move<value_type>::value;
 };
 
-template<class T, std::size_t BlockBytes, std::size_t BlockSize>
-struct deque_block_size
+template<class T, std::size_t BlockBytes, std::size_t BlockSize, class StoredSizeType>
+struct deque_block_traits
 {
    BOOST_CONTAINER_STATIC_ASSERT_MSG(!(BlockBytes && BlockSize), "BlockBytes and BlockSize can't be specified at the same time");
-   BOOST_STATIC_CONSTEXPR std::size_t block_bytes = BlockBytes ? BlockBytes : 512u;
-   BOOST_STATIC_CONSTEXPR std::size_t value       = BlockSize ? BlockSize : (sizeof(T) < block_bytes ? (block_bytes/sizeof(T)) : std::size_t(1));
-};
-
-namespace dtl {
-
-// Class invariants:
-//  For any nonsingular iterator i:
-//    i.node is the address of an element in the map array.  The
-//      contents of i.node is a pointer to the beginning of a node.
-//    i.first == //(i.node)
-//    i.last  == i.first + node_size
-//    i.cur is a pointer in the range [i.first, i.last).  NOTE:
-//      the implication of this is that i.cur is always a dereferenceable
-//      pointer, even if i is a past-the-end iterator.
-//  Start and Finish are always nonsingular iterators.  NOTE: this means
-//    that an empty deque must have one node, and that a deque
-//    with N elements, where N is the buffer size, must have two nodes.
-//  For every node other than start.node and finish.node, every element
-//    in the node is an initialized object.  If start.node == finish.node,
-//    then [start.cur, finish.cur) are initialized objects, and
-//    the elements outside that range are uninitialized storage.  Otherwise,
-//    [start.cur, start.last) and [finish.first, finish.cur) are initialized
-//    objects, and [start.first, start.cur) and [finish.cur, finish.last)
-//    are uninitialized storage.
-//  [map, map + map_size) is a valid, non-empty range.
-//  [start.node, finish.node] is a valid range contained within
-//    [map, map + map_size).
-//  A pointer in the range [map, map + map_size) points to an allocated node
-//    if and only if the pointer is in the range [start.node, finish.node].
-
-#define BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL 0
-
-#if BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL == 0
-template<class Pointer, bool IsConst>
-class deque_iterator
-{
-   public:
-   typedef std::random_access_iterator_tag                                          iterator_category;
-   typedef typename boost::intrusive::pointer_traits<Pointer>::element_type         value_type;
-   typedef typename boost::intrusive::pointer_traits<Pointer>::difference_type      difference_type;
-   typedef typename boost::intrusive::pointer_traits<Pointer>::size_type            size_type;
-   typedef typename if_c
-      < IsConst
-      , typename boost::intrusive::pointer_traits<Pointer>::template
-                                 rebind_pointer<const value_type>::type
-      , Pointer
-      >::type                                                                       pointer;
-   typedef typename if_c
-      < IsConst
-      , const value_type&
-      , value_type&
-      >::type                                                                       reference;
-
-   class nat;
-   typedef typename dtl::if_c< IsConst
-                             , deque_iterator<Pointer, false>
-                             , nat>::type                                           nonconst_iterator;
-
-   typedef Pointer                                                                  val_alloc_ptr;
-   typedef typename boost::intrusive::pointer_traits<Pointer>::
-      template rebind_pointer<Pointer>::type                                        index_pointer;
-
-   Pointer m_cur;
-   Pointer m_first;
-   Pointer m_last;
-   index_pointer  m_node;
-
-   public:
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_cur()          const  {  return m_cur;  }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_first()        const  {  return m_first;  }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_last()         const  {  return m_last;  }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline index_pointer get_node()   const  {  return m_node;  }
-
-   inline deque_iterator(val_alloc_ptr x, index_pointer y, difference_type block_size) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(x), m_first(*y), m_last(*y + block_size), m_node(y)
-   {}
-
-   inline deque_iterator(val_alloc_ptr x, index_pointer y, size_type block_size) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(x), m_first(*y), m_last(*y + difference_type(block_size)), m_node(y)
-   {}
-
-   inline deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(), m_first(), m_last(), m_node()  //Value initialization to achieve "null iterators" (N3644)
-   {}
-
-   inline deque_iterator(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(x.get_cur()), m_first(x.get_first()), m_last(x.get_last()), m_node(x.get_node())
-   {}
-
-   inline deque_iterator(const nonconst_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(x.get_cur()), m_first(x.get_first()), m_last(x.get_last()), m_node(x.get_node())
-   {}
-
-   inline deque_iterator(Pointer cur, Pointer first, Pointer last, index_pointer node) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(cur), m_first(first), m_last(last), m_node(node)
-   {}
-
-   inline deque_iterator& operator=(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
-   {  m_cur = x.get_cur(); m_first = x.get_first(); m_last = x.get_last(); m_node = x.get_node(); return *this; }
-
-   inline deque_iterator<Pointer, false> unconst() const BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      return deque_iterator<Pointer, false>(this->get_cur(), this->get_first(), this->get_last(), this->get_node());
-   }
-
-   inline reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return *this->m_cur; }
-
-   inline pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return this->m_cur; }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD difference_type operator-(const deque_iterator& x) const BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      if(!this->m_cur && !x.m_cur){
-         return 0;
-      }
-      const difference_type block_size = m_last - m_first;
-      BOOST_ASSERT(block_size);
-      return block_size * (this->m_node - x.m_node - 1) +
-         (this->m_cur - this->m_first) + (x.m_last - x.m_cur);
-   }
-
-   deque_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      BOOST_ASSERT(!!m_cur);
-      ++this->m_cur;
-      if (this->m_cur == this->m_last) {
-         const difference_type block_size = m_last - m_first;
-         BOOST_ASSERT(block_size);
-         this->priv_set_node(this->m_node + 1, block_size);
-         this->m_cur = this->m_first;
-      }
-      return *this;
-   }
-
-   inline deque_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      deque_iterator tmp(*this);
-      ++*this;
-      return tmp;
-   }
-
-   deque_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      BOOST_ASSERT(!!m_cur);
-      if (this->m_cur == this->m_first) {
-         const difference_type block_size = m_last - m_first;
-         BOOST_ASSERT(block_size);
-         this->priv_set_node(this->m_node - 1, block_size);
-         this->m_cur = this->m_last;
-      }
-      --this->m_cur;
-      return *this;
-   }
+   //Calculate default block size
+   BOOST_STATIC_CONSTEXPR std::size_t default_block_bytes = sizeof(void*)*128u;
+   BOOST_STATIC_CONSTEXPR std::size_t default_block_start = (default_block_bytes - 1u)/sizeof(T) + 1u;
+   //Round to the next power of two
+   BOOST_STATIC_CONSTEXPR std::size_t default_block_size_upp_pow2  = dtl::upper_power_of_2_ct<std::size_t, default_block_start>::value;
+
+   //Check minimal size
+   BOOST_STATIC_CONSTEXPR std::size_t default_min_block_size_pow = 3u;
+   BOOST_STATIC_CONSTEXPR std::size_t default_min_block_size = 8u;
+   BOOST_STATIC_CONSTEXPR std::size_t default_block_size_initial  = default_block_size_upp_pow2 < default_min_block_size
+                                                                  ? default_min_block_size
+                                                                  : default_block_size_upp_pow2;
+
+   //Limit by stored size max value
+   BOOST_STATIC_CONSTEXPR std::size_t max_stored_size_block_size  = std::size_t(1u) << (sizeof(StoredSizeType)*CHAR_BIT - default_min_block_size_pow);
+   BOOST_STATIC_CONSTEXPR std::size_t default_block_size  = default_block_size_initial > max_stored_size_block_size
+                                                                                       ? max_stored_size_block_size
+                                                                                       : default_block_size_initial;
+   //Now select between the default or the specified by the user
+   BOOST_STATIC_CONSTEXPR std::size_t value  = BlockSize  ? BlockSize
+                                             : BlockBytes ? (BlockBytes-1u)/sizeof(T) + 1u : default_block_size
+                                                                                   ;
+   BOOST_CONTAINER_STATIC_ASSERT_MSG(value <= max_stored_size_block_size, "BlockSize or BlockBytes is too big for the stored_size_type");
 
-   inline deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      deque_iterator tmp(*this);
-      --*this;
-      return tmp;
-   }
-
-   deque_iterator& operator+=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      if (!n)
-         return *this;
-      BOOST_ASSERT(!!m_cur);
-      const difference_type offset = n + (this->m_cur - this->m_first);
-      const difference_type block_size = m_last - m_first;
-      BOOST_ASSERT(block_size);
-      if (offset >= 0 && offset < block_size)
-         this->m_cur += difference_type(n);
-      else {
-         const difference_type node_offset =
-            offset > 0 ? (offset / block_size)
-                       : (-difference_type((-offset - 1) / block_size) - 1);
-         this->priv_set_node(this->m_node + node_offset, size_type(block_size));
-         this->m_cur = this->m_first +
-         (offset - node_offset * block_size);
-      }
-      return *this;
-   }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      deque_iterator operator+(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-      {  deque_iterator tmp(*this); return tmp += n;  }
-
-   inline
-      deque_iterator& operator-=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW
-      { return *this += -n; }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      deque_iterator operator-(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-      {  deque_iterator tmp(*this); return tmp -= n;  }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-      { return *(*this + n); }
-
-   //Comparisons
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      { return l.m_cur == r.m_cur; }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      { return l.m_cur != r.m_cur; }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator<(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      {  return (l.m_node == r.m_node) ? (l.m_cur < r.m_cur) : (l.m_node < r.m_node);  }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      { return r < l; }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator<=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      { return !(r < l); }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator>=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      { return !(l < r); }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW
-      {  return x += n;  }
-
-   inline void priv_set_node(index_pointer new_node, size_type block_size) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->priv_set_node(new_node, difference_type(block_size)); }
-
-   inline void priv_set_node(index_pointer new_node, difference_type block_size) BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      this->m_node = new_node;
-      this->m_first = *new_node;
-      this->m_last = this->m_first + block_size;
-   }
 };
 
-#elif BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL == 1
-
-template<class Pointer, bool IsConst, unsigned BlockBytes, unsigned BlockSize>
-class deque_iterator
-{
-   public:
-   typedef std::random_access_iterator_tag                                          iterator_category;
-   typedef typename boost::intrusive::pointer_traits<Pointer>::element_type         value_type;
-   typedef typename boost::intrusive::pointer_traits<Pointer>::difference_type      difference_type;
-   typedef typename boost::intrusive::pointer_traits<Pointer>::size_type            size_type;
-   typedef typename if_c
-      < IsConst
-      , typename boost::intrusive::pointer_traits<Pointer>::template
-                                 rebind_pointer<const value_type>::type
-      , Pointer
-      >::type                                                                       pointer;
-   typedef typename if_c
-      < IsConst
-      , const value_type&
-      , value_type&
-      >::type                                                                       reference;
-
-   BOOST_CONSTEXPR inline static size_type get_block_size() BOOST_NOEXCEPT_OR_NOTHROW
-      { return deque_block_size<value_type, BlockBytes, BlockSize>::value; }
-
-   BOOST_CONSTEXPR inline static difference_type get_block_ssize() BOOST_NOEXCEPT_OR_NOTHROW
-      { return difference_type((get_block_size())); }
-
-   class nat;
-   typedef typename dtl::if_c< IsConst
-                             , deque_iterator<Pointer, false, BlockBytes, BlockSize>
-                             , nat>::type                                           nonconst_iterator;
-
-   typedef Pointer                                                                  val_alloc_ptr;
-   typedef typename boost::intrusive::pointer_traits<Pointer>::
-      template rebind_pointer<Pointer>::type                                        index_pointer;
-
-   Pointer m_cur;
-   Pointer m_first;
-   index_pointer  m_node;
-
-   public:
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_cur()          const  {  return m_cur;  }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_first()        const  {  return m_first;  }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_last()         const  { return m_first + get_block_ssize(); }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline index_pointer get_node()   const  {  return m_node;  }
-
-   inline deque_iterator(val_alloc_ptr x, index_pointer y, difference_type ) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(x), m_first(*y), m_node(y)
-   {}
-
-   inline deque_iterator(val_alloc_ptr x, index_pointer y, size_type ) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(x), m_first(*y), m_node(y)
-   {}
-
-   inline deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(), m_first(), m_node()  //Value initialization to achieve "null iterators" (N3644)
-   {}
-
-   inline deque_iterator(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(x.get_cur()), m_first(x.get_first()), m_node(x.get_node())
-   {}
-
-   inline deque_iterator(const nonconst_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(x.get_cur()), m_first(x.get_first()), m_node(x.get_node())
-   {}
-
-   inline deque_iterator(Pointer cur, Pointer first, index_pointer node) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(cur), m_first(first), m_node(node)
-   {}
-
-   inline deque_iterator& operator=(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
-   {  m_cur = x.get_cur(); m_first = x.get_first(); m_node = x.get_node(); return *this; }
-
-   inline nonconst_iterator unconst() const BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      return nonconst_iterator(this->get_cur(), this->get_first(), this->get_node());
-   }
-
-   inline reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return *this->m_cur; }
-
-   inline pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return this->m_cur; }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD difference_type operator-(const deque_iterator& x) const BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      if(!this->m_cur && !x.m_cur){
-         return 0;
-      }
-      const difference_type block_size = get_block_ssize();
-      BOOST_ASSERT(block_size);
-      return block_size * (this->m_node - x.m_node - 1) +
-         (this->m_cur - this->m_first) + ((x.m_first+block_size) - x.m_cur);
-   }
-
-   deque_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      BOOST_ASSERT(!!m_cur);
-      ++this->m_cur;
-      const difference_type block_size = get_block_ssize();
-      if (this->m_cur == (this->m_first+block_size)) {
-
-         BOOST_ASSERT(block_size);
-         ++this->m_node;
-         this->m_first = *this->m_node;
-         this->m_cur = this->m_first;
-      }
-      return *this;
-   }
-
-   inline deque_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      deque_iterator tmp(*this);
-      ++*this;
-      return tmp;
-   }
-
-   deque_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      BOOST_ASSERT(!!m_cur);
-      if (this->m_cur == this->m_first) {
-         --this->m_node;
-         this->m_first = *this->m_node;
-         this->m_cur = this->m_first + get_block_ssize();
-      }
-      --this->m_cur;
-      return *this;
-   }
-
-   inline deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      deque_iterator tmp(*this);
-      --*this;
-      return tmp;
-   }
-
-   deque_iterator& operator+=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      if (!n)
-         return *this;
-      BOOST_ASSERT(!!m_cur);
-      const difference_type offset = n + (this->m_cur - this->m_first);
-      const difference_type block_size = get_block_ssize();
-      BOOST_ASSERT(block_size);
-      if (offset >= 0 && offset < block_size)
-         this->m_cur += difference_type(n);
-      else {
-         const difference_type node_offset =
-            offset > 0 ? (offset / block_size)
-                       : (-difference_type((-offset - 1) / block_size) - 1);
-         this->m_node += node_offset;
-         this->m_first = *this->m_node;
-         this->m_cur = this->m_first + (offset - node_offset * block_size);
-      }
-      return *this;
-   }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      deque_iterator operator+(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-      {  deque_iterator tmp(*this); return tmp += n;  }
-
-   inline
-      deque_iterator& operator-=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW
-      { return *this += -n; }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      deque_iterator operator-(difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-      {  deque_iterator tmp(*this); return tmp -= n;  }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-      { return *(*this + n); }
-
-   //Comparisons
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      { return l.m_cur == r.m_cur; }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator!=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      { return l.m_cur != r.m_cur; }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator<(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      {  return (l.m_node == r.m_node) ? (l.m_cur < r.m_cur) : (l.m_node < r.m_node);  }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator>(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      { return r < l; }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator<=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      { return !(r < l); }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend bool operator>=(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
-      { return !(l < r); }
-
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
-      friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW
-      {  return x += n;  }
-
-   inline void priv_set_node(index_pointer new_node, size_type ) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->priv_set_node(new_node, difference_type()); }
-
-   inline void priv_set_node(index_pointer new_node, difference_type) BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      this->m_node = new_node;
-      this->m_first = *new_node;
-   }
-};
-
-#elif BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL == 2
-
-template<class Pointer, bool IsConst, unsigned BlockBytes, unsigned BlockSize>
+// Class invariants:
+//  For any nonsingular iterator i:
+//    i.node is the address of an element in the map array.  The
+//      contents of i.node is a pointer to the beginning of a node.
+//    i.cur is a pointer in the range [i.first, i.last).  NOTE:
+//      the implication of this is that i.cur is always a dereferenceable
+//      pointer, even if i is a past-the-end iterator.
+//  For every node other than start.node and finish.node, every element
+//    in the node is an initialized object.  If start.node == finish.node,
+//    then [start.cur, finish.cur) are initialized objects, and
+//    the elements outside that range are uninitialized storage.  Otherwise,
+//    [start.cur, start.last) and [finish.first, finish.cur) are initialized
+//    objects, and [start.first, start.cur) and [finish.cur, finish.last)
+//    are uninitialized storage.
+//  [map, map + map_size) is a valid range.
+//  [start.node, finish.node] is a valid range contained within
+//    [map, map + map_size).
+//  A pointer in the range [map, map + map_size) points to an allocated node
+//    if and only if the pointer is in the range [start.node, finish.node].
+template<class Pointer, bool IsConst, unsigned BlockBytes, unsigned BlockSize, class StoredSizeType>
 class deque_iterator
 {
    public:
@@ -541,13 +129,13 @@ class deque_iterator
    typedef typename boost::intrusive::pointer_traits<Pointer>::element_type         value_type;
    typedef typename boost::intrusive::pointer_traits<Pointer>::difference_type      difference_type;
    typedef typename boost::intrusive::pointer_traits<Pointer>::size_type            size_type;
-   typedef typename if_c
+   typedef typename dtl::if_c
       < IsConst
       , typename boost::intrusive::pointer_traits<Pointer>::template
                                  rebind_pointer<const value_type>::type
       , Pointer
       >::type                                                                       pointer;
-   typedef typename if_c
+   typedef typename dtl::if_c
       < IsConst
       , const value_type&
       , value_type&
@@ -555,37 +143,40 @@ class deque_iterator
 
    BOOST_CONSTEXPR inline static size_type get_block_size() BOOST_NOEXCEPT_OR_NOTHROW
    {
-      BOOST_CONTAINER_STATIC_ASSERT((deque_block_size<value_type, BlockBytes, BlockSize>::value));
-      return deque_block_size<value_type, BlockBytes, BlockSize>::value;
+      return deque_block_traits<value_type, BlockBytes, BlockSize, StoredSizeType>::value;
    }
 
    BOOST_CONSTEXPR inline static difference_type get_block_ssize() BOOST_NOEXCEPT_OR_NOTHROW
       { return difference_type((get_block_size())); }
 
-   class nat;
-   typedef typename dtl::if_c< IsConst
-                             , deque_iterator<Pointer, false, BlockBytes, BlockSize>
-                             , nat>::type                                           nonconst_iterator;
-
    typedef Pointer                                                                  val_alloc_ptr;
    typedef typename boost::intrusive::pointer_traits<Pointer>::
       template rebind_pointer<Pointer>::type                                        index_pointer;
 
+   class nat
+   {
+      public:
+      inline Pointer get_cur()          const  {  return Pointer();  }
+      inline index_pointer get_node()   const  {  return index_pointer();  }
+   };
+
+   typedef typename dtl::if_c< IsConst
+                             , deque_iterator<Pointer, false, BlockBytes, BlockSize, StoredSizeType>
+                             , nat>::type                                           nonconst_iterator_arg;
+
+   typedef deque_iterator<Pointer, false, BlockBytes, BlockSize, StoredSizeType> nonconst_iterator;
+
    Pointer m_cur;
    index_pointer  m_node;
 
    public:
 
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_cur()          const  {  return m_cur;  }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_first()        const  {  return *m_node;  }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_last()         const  { return *m_node + get_block_ssize(); }
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline index_pointer get_node()   const  {  return m_node;  }
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_first()        const  {  return *m_node;  }
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline Pointer get_last()         const  {  return *m_node + get_block_ssize(); }
 
-   inline deque_iterator(val_alloc_ptr x, index_pointer y, difference_type ) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(x), m_node(y)
-   {}
-
-   inline deque_iterator(val_alloc_ptr x, index_pointer y, size_type ) BOOST_NOEXCEPT_OR_NOTHROW
+   inline deque_iterator(val_alloc_ptr x, index_pointer y) BOOST_NOEXCEPT_OR_NOTHROW
       : m_cur(x), m_node(y)
    {}
 
@@ -597,17 +188,16 @@ class deque_iterator
       : m_cur(x.get_cur()), m_node(x.get_node())
    {}
 
-   inline deque_iterator(const nonconst_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
+   inline deque_iterator(const nonconst_iterator_arg& x) BOOST_NOEXCEPT_OR_NOTHROW
       : m_cur(x.get_cur()), m_node(x.get_node())
    {}
 
-   inline deque_iterator(Pointer cur, index_pointer node) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_cur(cur), m_node(node)
-   {}
-
    inline deque_iterator& operator=(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
    {  m_cur = x.get_cur(); m_node = x.get_node(); return *this; }
 
+   inline deque_iterator& operator=(const nonconst_iterator_arg& x) BOOST_NOEXCEPT_OR_NOTHROW
+   {  m_cur = x.get_cur(); m_node = x.get_node(); return *this; }
+
    inline nonconst_iterator unconst() const BOOST_NOEXCEPT_OR_NOTHROW
    {
       return nonconst_iterator(this->get_cur(), this->get_node());
@@ -621,21 +211,20 @@ class deque_iterator
 
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD difference_type operator-(const deque_iterator& x) const BOOST_NOEXCEPT_OR_NOTHROW
    {
-      if(!this->m_cur && !x.m_cur){
+      if(this->m_cur == x.m_cur){ //Includes when both are null
          return 0;
       }
-      const difference_type block_size = get_block_ssize();
-      BOOST_ASSERT(block_size);
-      return block_size * (this->m_node - x.m_node - 1) +
-         (this->m_cur - this->get_first()) + (x.get_last() - x.m_cur);
+      BOOST_CONSTEXPR_OR_CONST difference_type block_size = get_block_ssize();
+      return block_size * (this->m_node - x.m_node) +
+         (this->m_cur - this->get_first()) - (x.m_cur - x.get_first());
    }
 
    deque_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!!m_cur);
       ++this->m_cur;
-      if (this->m_cur == (this->get_last())) {
-
+      const Pointer last = *m_node + get_block_ssize();
+      if (BOOST_UNLIKELY(this->m_cur == last)) {
          ++this->m_node;
          this->m_cur = *this->m_node;
       }
@@ -649,17 +238,30 @@ class deque_iterator
       return tmp;
    }
 
+//Some GCC versions issue bogus warnings about array bounds here
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#  pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
+
    deque_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!!m_cur);
-      if (this->m_cur == this->get_first()) {
+      const Pointer first = *m_node;
+      if (BOOST_UNLIKELY(this->m_cur == first)) {
          --this->m_node;
-         this->m_cur = this->get_last();
+         this->m_cur = *this->m_node;
+         this->m_cur += get_block_ssize() - 1;
+      }
+      else {
+         --this->m_cur;
       }
-      --this->m_cur;
       return *this;
    }
 
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic pop
+#endif
+
    inline deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
    {
       deque_iterator tmp(*this);
@@ -669,20 +271,20 @@ class deque_iterator
 
    deque_iterator& operator+=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      if (!n)
-         return *this;
-      BOOST_ASSERT(!!m_cur);
-      const difference_type offset = n + (this->m_cur - this->get_first());
-      const difference_type block_size = get_block_ssize();
-      BOOST_ASSERT(block_size);
-      if (offset >= 0 && offset < block_size)
-         this->m_cur += difference_type(n);
-      else {
-         const difference_type node_offset =
-            offset > 0 ? (offset / block_size)
-                       : (-difference_type((-offset - 1) / block_size) - 1);
-         this->m_node += node_offset;
-         this->m_cur = this->get_first() + (offset - node_offset * block_size);
+      if (n){
+         BOOST_CONSTEXPR_OR_CONST difference_type block_size = get_block_ssize();
+
+         const difference_type offset = n + (this->m_cur - *this->m_node);
+
+         if (offset >= 0 && offset < block_size)
+            this->m_cur += difference_type(n);
+         else {
+            const difference_type node_offset =
+               offset > 0 ? (offset / block_size)
+                          : (-difference_type((-offset - 1) / block_size) - 1);
+            this->m_node += node_offset;
+            this->m_cur = *this->m_node + difference_type(offset - node_offset * block_size);
+         }
       }
       return *this;
    }
@@ -703,8 +305,10 @@ class deque_iterator
       reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!!m_cur);
-      const difference_type offset = n + (this->m_cur - this->get_first());
-      const difference_type block_size = get_block_ssize();
+      BOOST_CONSTEXPR_OR_CONST difference_type block_size = get_block_ssize();
+
+      const difference_type offset = n + (this->m_cur - *this->m_node);
+
       if (offset >= 0 && offset < block_size)
          return this->m_cur[difference_type(n)];
       else {
@@ -744,34 +348,26 @@ class deque_iterator
       friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW
       {  return x += n;  }
 
-   inline void priv_set_node(index_pointer new_node, size_type ) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->priv_set_node(new_node, difference_type()); }
-
-   inline void priv_set_node(index_pointer new_node, difference_type) BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      this->m_node = new_node;
-   }
+   inline void priv_set_node(index_pointer new_node) BOOST_NOEXCEPT_OR_NOTHROW
+   {  this->m_node = new_node;  }
 };
 
-#else
-
-#error "Invalid BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL"
-
-#endif
-}  //namespace dtl {
 
-template<class Options>
+template<class Options, class AllocatorSizeType>
 struct get_deque_opt
 {
-   typedef Options type;
+   typedef deque_opt< Options::block_bytes, Options::block_size
+                    , typename default_if_void<typename Options::stored_size_type, AllocatorSizeType>::type
+                    , Options::reservable> type;
 };
 
-template<>
-struct get_deque_opt<void>
+template<class AllocatorSizeType>
+struct get_deque_opt<void, AllocatorSizeType>
 {
-   typedef deque_null_opt type;
+   typedef deque_opt<deque_null_opt::block_bytes, deque_null_opt::block_size, AllocatorSizeType, deque_null_opt::reservable> type;
 };
 
+
 // Deque base class.  It has two purposes.  First, its constructor
 //  and destructor allocate (but don't initialize) storage.  This makes
 //  exception safety easier.
@@ -796,47 +392,59 @@ class deque_base
    typedef typename ptr_alloc_traits_type::const_pointer          ptr_alloc_cptr;
    typedef typename ptr_alloc_traits_type::reference              ptr_alloc_ref;
    typedef typename ptr_alloc_traits_type::const_reference        ptr_alloc_cref;
-   typedef Allocator                                                      allocator_type;
+   typedef Allocator                                              allocator_type;
    typedef allocator_type                                         stored_allocator_type;
    typedef val_alloc_size                                         size_type;
    typedef val_alloc_diff                                         difference_type;
 
    private:
-   typedef typename get_deque_opt<Options>::type                  options_type;
+   typedef typename get_deque_opt<Options, val_alloc_size>::type  options_type;
 
    protected:
-   #if BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL == 0
-   typedef dtl::deque_iterator<val_alloc_ptr, false> iterator;
-   typedef dtl::deque_iterator<val_alloc_ptr, true> const_iterator;
-   #else
-   typedef dtl::deque_iterator<val_alloc_ptr, false, options_type::block_bytes, options_type::block_size> iterator;
-   typedef dtl::deque_iterator<val_alloc_ptr, true, options_type::block_bytes, options_type::block_size> const_iterator;
-   #endif
+   typedef typename options_type::stored_size_type                stored_size_type;
+   typedef deque_iterator< val_alloc_ptr, false
+                         , options_type::block_bytes
+                         , options_type::block_size
+                         , stored_size_type>                      iterator;
+   typedef deque_iterator< val_alloc_ptr, true
+                         , options_type::block_bytes
+                         , options_type::block_size
+                         , stored_size_type>                      const_iterator;
+
+   static const bool is_reservable = options_type::reservable;
 
    BOOST_CONSTEXPR inline static val_alloc_diff get_block_ssize() BOOST_NOEXCEPT_OR_NOTHROW
       { return val_alloc_diff((get_block_size())); }
 
    BOOST_CONSTEXPR inline static size_type get_block_size() BOOST_NOEXCEPT_OR_NOTHROW
-      { return deque_block_size<val_alloc_val, options_type::block_bytes, options_type::block_size>::value; }
+      { return deque_block_traits<val_alloc_val, options_type::block_bytes, options_type::block_size, stored_size_type>::value; }
 
    typedef deque_value_traits<val_alloc_val>             traits_t;
    typedef ptr_alloc_t                                   map_allocator_type;
 
-   inline val_alloc_ptr priv_allocate_node()
-      {  return this->alloc().allocate(get_block_size());  }
+   inline val_alloc_ptr prot_allocate_node()
+   {
+      return this->alloc().allocate(get_block_size());
+   }
 
-   inline void priv_deallocate_node(val_alloc_ptr p) BOOST_NOEXCEPT_OR_NOTHROW
-      {  this->alloc().deallocate(p, get_block_size());  }
+   inline void prot_deallocate_node(val_alloc_ptr p) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      this->alloc().deallocate(p, get_block_size());
+   }
 
-   inline ptr_alloc_ptr priv_allocate_map(size_type n)
-      { return this->ptr_alloc().allocate(n); }
+   inline ptr_alloc_ptr prot_allocate_map(size_type n)
+   {
+      return this->ptr_alloc().allocate(n);
+   }
 
-   inline void priv_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_NOEXCEPT_OR_NOTHROW
-      { this->ptr_alloc().deallocate(p, n); }
+   inline void prot_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+        this->ptr_alloc().deallocate(p, n);
+   }
 
    inline deque_base(size_type num_elements, const allocator_type& a)
       :  members_(a)
-   { this->priv_initialize_map(num_elements); }
+   { this->prot_initialize_map_and_nodes(num_elements); }
 
    inline explicit deque_base(const allocator_type& a)
       :  members_(a)
@@ -854,8 +462,8 @@ class deque_base
    ~deque_base()
    {
       if (this->members_.m_map) {
-         this->priv_destroy_nodes(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1);
-         this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
+         this->prot_deallocate_all_nodes();
+         this->prot_deallocate_map(this->members_.m_map, this->members_.m_map_size);
       }
    }
 
@@ -866,117 +474,542 @@ class deque_base
 
    void swap_members(deque_base &x) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      ::boost::adl_move_swap(this->members_.m_start, x.members_.m_start);
-      ::boost::adl_move_swap(this->members_.m_finish, x.members_.m_finish);
-      ::boost::adl_move_swap(this->members_.m_map, x.members_.m_map);
-      ::boost::adl_move_swap(this->members_.m_map_size, x.members_.m_map_size);
+      this->members_.swap(x.members_);
+   }
+
+   void test_size_against_max(size_type n)
+   {
+      const size_type max_alloc = val_alloc_traits_type::max_size(this->alloc());
+      const size_type max = max_alloc <= stored_size_type(-1) ? max_alloc : stored_size_type(-1);
+      if (BOOST_UNLIKELY(max < n) )
+         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
+   }
+
+   void test_size_against_n_nodes(size_type n_nodes)
+   {
+      test_size_against_max(size_type(size_type(n_nodes * get_block_size()) - 1u));
+   }
+
+   void prot_initialize_map_and_nodes(size_type num_elements)
+   {
+      BOOST_CONSTEXPR_OR_CONST size_type block_size = get_block_size();
+      //Even a zero element initialized map+nodes needs at least 1 node (for sentinel finish position)
+      size_type num_nodes = size_type(num_elements / block_size + 1u);
+
+      //Allocate at least one extra slot on each end to avoid inmediate map reallocation on push/front insertions
+      const size_type map_size = dtl::max_value(size_type(InitialMapSize), size_type(num_nodes + 2u));
+      const size_type start_map_pos = size_type(map_size - num_nodes)/2u;
+
+      //The end position must be representable in stored_size_type
+      this->test_size_against_n_nodes(map_size);
+
+      this->members_.m_map = this->prot_allocate_map(map_size);
+      this->members_.m_map_size = static_cast<stored_size_type>(map_size);
+
+
+      BOOST_CONTAINER_TRY {
+         BOOST_IF_CONSTEXPR(is_reservable){   //reservable implies all slots are allocated with nodes
+            this->prot_allocate_nodes(this->members_.m_map, map_size);
+         }
+         else{  //Otherwise only create the nodes that will hold values
+            this->prot_allocate_nodes(this->members_.m_map + difference_type(start_map_pos), num_nodes);
+         }
+      }
+      BOOST_CONTAINER_CATCH(...){
+         this->prot_deallocate_map(this->members_.m_map, this->members_.m_map_size);
+         this->members_.m_map = ptr_alloc_ptr();
+         this->members_.m_map_size = 0;
+         BOOST_CONTAINER_RETHROW
+      }
+      BOOST_CONTAINER_CATCH_END
+
+      this->prot_set_start_finish_from_node(start_map_pos, num_elements);
+   }
+
+   static size_type priv_new_offset(bool add_at_front, size_type map_size, size_type active_nodes, size_type additional_nodes)
+   {
+      return size_type(size_type(map_size - active_nodes) / 2 + (add_at_front ? +additional_nodes : +0));
    }
 
-   void priv_initialize_map(size_type num_elements)
+   void prot_reallocate_map_and_nodes  //is_reservable == true
+      (dtl::bool_<true>, const size_type new_elems, const bool add_at_front)
    {
-//      if(num_elements){
-         size_type num_nodes = num_elements / get_block_size() + 1;
+      const ptr_alloc_ptr start_node = this->prot_start_node();
+      const size_type old_active_nodes = size_type(this->prot_finish_node() + 1u - start_node);
+
+      const size_type additional_nodes = size_type((new_elems - 1u)/get_block_size() + 1u);
+      const size_type new_active_nodes = size_type(old_active_nodes + additional_nodes);
 
-         this->members_.m_map_size = dtl::max_value((size_type) InitialMapSize, num_nodes + 2);
-         this->members_.m_map = this->priv_allocate_map(this->members_.m_map_size);
+      ptr_alloc_ptr new_nstart;
+      const size_type old_map_size = this->members_.m_map_size;
+      const ptr_alloc_ptr old_map  = this->members_.m_map;
 
-         ptr_alloc_ptr nstart = this->members_.m_map + difference_type(this->members_.m_map_size - num_nodes) / 2;
-         ptr_alloc_ptr nfinish = nstart + difference_type(num_nodes);
+      //Check for 1.5 factor
+      if (old_map_size/3u >= new_active_nodes/2u) {
+         new_nstart = old_map + difference_type(priv_new_offset(add_at_front, old_map_size, new_active_nodes, additional_nodes));
+         const ptr_alloc_ptr end_node = start_node + difference_type(old_active_nodes);
+         if (new_nstart < start_node)
+            boost::movelib::rotate_gcd(new_nstart, start_node, end_node);
+         else
+            boost::movelib::rotate_gcd(start_node, end_node, new_nstart + old_active_nodes);
+      }
+      else {
+         //1.5 increase, but at least one spare slot on each end
+         const size_type new_map_size = dtl::max_value(size_type(old_map_size + old_map_size/2u), size_type(new_active_nodes + 2u));
+
+         //The end position must be representable in stored_size_type
+         this->test_size_against_n_nodes(new_map_size);
+
+         const ptr_alloc_ptr new_map = this->prot_allocate_map(new_map_size);
+         const size_type new_active_off = priv_new_offset(add_at_front, new_map_size, new_active_nodes, additional_nodes);
+         new_nstart = new_map + difference_type(new_active_off);
+
+         const size_type new_nodes = size_type(new_map_size - old_map_size);
 
          BOOST_CONTAINER_TRY {
-            this->priv_create_nodes(nstart, nfinish);
+            this->prot_allocate_nodes(new_map, new_nodes);
          }
          BOOST_CONTAINER_CATCH(...){
-            this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
-            this->members_.m_map = 0;
-            this->members_.m_map_size = 0;
+            this->prot_deallocate_map(new_map, new_map_size);
             BOOST_CONTAINER_RETHROW
          }
          BOOST_CONTAINER_CATCH_END
 
-         this->members_.m_start.priv_set_node(nstart, get_block_size());
-         this->members_.m_finish.priv_set_node(nfinish - 1, get_block_size());
-         this->members_.m_start.m_cur = this->members_.m_start.get_first();
-         this->members_.m_finish.m_cur = this->members_.m_finish.get_first() + difference_type(num_elements % get_block_size());
-//      }
+         const ptr_alloc_ptr new_old_node_limit = new_map + difference_type(new_nodes);
+
+         //Move old nodes from the old map, rotate to the right position and deallocate the old map
+         boost::container::move_n(old_map, old_map_size, new_old_node_limit);
+
+         const size_type old_active_off = size_type(start_node - old_map);
+         const ptr_alloc_ptr active_start = new_old_node_limit + difference_type(old_active_off);
+         const ptr_alloc_ptr active_end   = active_start       + difference_type(old_active_nodes);
+         if (new_nstart < active_start)
+            boost::movelib::rotate_gcd(new_nstart, active_start, active_end);
+         else
+            boost::movelib::rotate_gcd(active_start, active_end, new_nstart + difference_type(old_active_nodes));
+
+         this->prot_deallocate_map(old_map, old_map_size);
+
+         this->members_.m_map = new_map;
+         this->members_.m_map_size = static_cast<stored_size_type>(new_map_size);
+      }
+
+      this->prot_start_update_node(new_nstart);
+      this->prot_finish_update_node(new_nstart + difference_type(old_active_nodes - 1u));
+   }
+
+   void prot_reallocate_map_and_nodes  //is_reservable == false
+      (dtl::bool_<false>, const size_type new_elems, const bool add_at_front)
+   {
+      const size_type additional_nodes = size_type((new_elems - 1u)/get_block_size() + 1u);
+
+      const ptr_alloc_ptr start_node = this->prot_start_node();
+      const ptr_alloc_ptr finish_node = this->prot_finish_node();
+
+      size_type unused_slots = add_at_front ? size_type(start_node - this->members_.m_map)
+                                            : size_type(this->members_.m_map_size - 1u - size_type(finish_node - this->members_.m_map));
+      if (additional_nodes > unused_slots){
+         const ptr_alloc_ptr next_finish_node = finish_node + 1u;
+         const size_type old_active_nodes = size_type(next_finish_node - start_node);
+         const size_type new_active_nodes = size_type(old_active_nodes + additional_nodes);
+
+         ptr_alloc_ptr new_nstart;
+         const size_type old_map_size = this->members_.m_map_size;
+         const ptr_alloc_ptr old_map  = this->members_.m_map;
+
+         if (old_map_size/2u >= new_active_nodes) {
+            new_nstart = old_map + difference_type(priv_new_offset(add_at_front, old_map_size, new_active_nodes, additional_nodes));
+            if (new_nstart < start_node)
+               boost::container::move_n(start_node, old_active_nodes, new_nstart);
+            else
+               boost::container::move_backward_n(next_finish_node, old_active_nodes, new_nstart + difference_type(old_active_nodes));
+         }
+         else {
+            //Doubling size, but at least one spare slot on each end
+            const size_type new_map_size = dtl::max_value(size_type(old_map_size*2), size_type(new_active_nodes + 2u));
+
+            //The end position must be representable in stored_size_type
+            this->test_size_against_n_nodes(new_map_size);
+
+            const ptr_alloc_ptr new_map = this->prot_allocate_map(new_map_size);
+
+            new_nstart = new_map + difference_type(priv_new_offset(add_at_front, new_map_size, new_active_nodes, additional_nodes));
+            boost::container::move_n(start_node, old_active_nodes, new_nstart);
+
+            this->prot_deallocate_map(old_map, old_map_size);
+
+            this->members_.m_map = new_map;
+            this->members_.m_map_size = static_cast<stored_size_type>(new_map_size);
+         }
+
+         this->prot_start_update_node(new_nstart);
+         this->prot_finish_update_node(new_nstart + difference_type(old_active_nodes - 1u));
+      }
+   
+      if(add_at_front)
+         this->prot_allocate_nodes(this->prot_start_node() - difference_type(additional_nodes), additional_nodes);
+      else
+         this->prot_allocate_nodes(this->prot_finish_node() + 1, additional_nodes);
    }
 
-   void priv_create_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish)
+   void prot_allocate_nodes(ptr_alloc_ptr start, size_type n)
    {
-      ptr_alloc_ptr cur = nstart;
+      size_type i = 0;
       BOOST_CONTAINER_TRY {
-         for (; cur < nfinish; ++cur)
-            *cur = this->priv_allocate_node();
+         for (; i < n; ++i)
+            start[difference_type(i)] = this->prot_allocate_node();
       }
-      BOOST_CONTAINER_CATCH(...){
-         this->priv_destroy_nodes(nstart, cur);
+      BOOST_CONTAINER_CATCH(...) {
+         for (size_type j = 0; j < i; ++j)
+            this->prot_deallocate_node(start[difference_type(j)]);
          BOOST_CONTAINER_RETHROW
       }
       BOOST_CONTAINER_CATCH_END
    }
 
-   void priv_destroy_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_NOEXCEPT_OR_NOTHROW
+
+   void prot_deallocate_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      for (ptr_alloc_ptr n = nstart; n < nfinish; ++n){
+         this->prot_deallocate_node(*n);
+      }
+   }
+
+   void prot_deallocate_nodes_if_not_reservable(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      (void)nstart; (void)nfinish;
+      BOOST_IF_CONSTEXPR(!is_reservable)
+         this->prot_deallocate_nodes(nstart, nfinish);
+   }
+
+   void prot_deallocate_node_if_not_reservable(val_alloc_ptr p) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      (void)p;
+      BOOST_IF_CONSTEXPR(!is_reservable)
+         this->prot_deallocate_node(p);
+   }
+
+   void prot_deallocate_all_nodes()
    {
-      for (ptr_alloc_ptr n = nstart; n < nfinish; ++n)
-         this->priv_deallocate_node(*n);
+      BOOST_IF_CONSTEXPR(is_reservable)
+         this->prot_deallocate_nodes(this->members_.m_map, this->members_.m_map + difference_type(this->members_.m_map_size));
+      else
+         this->prot_deallocate_nodes(this->prot_start_node(), this->prot_finish_node() + 1);
    }
 
-   void priv_clear_map() BOOST_NOEXCEPT_OR_NOTHROW
+
+   void prot_clear_map() BOOST_NOEXCEPT_OR_NOTHROW
    {
       if (this->members_.m_map) {
-         this->priv_destroy_nodes(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1);
-         this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
-         this->members_.m_map = 0;
-         this->members_.m_map_size = 0;
-         this->members_.m_start = iterator();
-         this->members_.m_finish = this->members_.m_start;
+         this->prot_deallocate_all_nodes();
+         this->prot_deallocate_map(this->members_.m_map, this->members_.m_map_size);
+         this->members_.m_map = ptr_alloc_ptr();
+         this->members_.m_map_size = 0u;
+         this->members_.m_start_off = 0u;
+         this->members_.m_finish_off = 0u;
       }
    }
 
-   enum { InitialMapSize = 8 };
+   enum { InitialMapSize = 4 };
 
    protected:
    struct members_holder
       :  public ptr_alloc_t
       ,  public allocator_type
    {
+      friend class deque_base;
       members_holder()
          :  map_allocator_type(), allocator_type()
-         ,  m_map(0), m_map_size(0)
-         ,  m_start(), m_finish(m_start)
+         ,  m_map(), m_map_size()
+         ,  m_start_off(), m_finish_off()
       {}
 
       explicit members_holder(const allocator_type &a)
          :  map_allocator_type(a), allocator_type(a)
-         ,  m_map(0), m_map_size(0)
-         ,  m_start(), m_finish(m_start)
+         ,  m_map(), m_map_size()
+         ,  m_start_off(), m_finish_off()
       {}
 
       template<class ValAllocConvertible, class PtrAllocConvertible>
       members_holder(BOOST_FWD_REF(PtrAllocConvertible) pa, BOOST_FWD_REF(ValAllocConvertible) va)
          : map_allocator_type(boost::forward<PtrAllocConvertible>(pa))
          , allocator_type    (boost::forward<ValAllocConvertible>(va))
-         , m_map(0), m_map_size(0)
-         , m_start(), m_finish(m_start)
+         , m_map(), m_map_size()
+         , m_start_off(), m_finish_off()
       {}
 
-      ptr_alloc_ptr   m_map;
-      val_alloc_size  m_map_size;
-      iterator        m_start;
-      iterator        m_finish;
+      void swap(members_holder &x) BOOST_NOEXCEPT_OR_NOTHROW
+      {
+         ::boost::adl_move_swap(this->m_map, x.m_map);
+         ::boost::adl_move_swap(this->m_map_size, x.m_map_size);
+         ::boost::adl_move_swap(this->m_start_off, x.m_start_off);
+         ::boost::adl_move_swap(this->m_finish_off, x.m_finish_off);
+      }
+
+      ptr_alloc_ptr     m_map;
+      stored_size_type  m_map_size;
+      private:
+      stored_size_type  m_start_off;
+      stored_size_type  m_finish_off;
    } members_;
 
    inline ptr_alloc_t &ptr_alloc() BOOST_NOEXCEPT_OR_NOTHROW
    {  return members_;  }
 
-   inline const ptr_alloc_t &ptr_alloc() const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return members_;  }
+   inline const ptr_alloc_t &ptr_alloc() const BOOST_NOEXCEPT_OR_NOTHROW
+   {  return members_;  }
+
+   inline allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW
+   {  return members_;  }
+
+   inline const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
+   {  return members_;  }
+
+   static BOOST_CONTAINER_FORCEINLINE val_alloc_ptr prot_node_last(ptr_alloc_ptr idx)
+   {
+      BOOST_CONSTEXPR_OR_CONST std::size_t block_size = deque_base::get_block_size();
+      return *idx + difference_type(block_size - 1u);
+   }
+
+   BOOST_CONTAINER_FORCEINLINE size_type prot_front_free_capacity() const
+   {
+      BOOST_IF_CONSTEXPR(is_reservable){
+         return static_cast<size_type>(this->members_.m_start_off);
+      }
+      else{
+         BOOST_CONSTEXPR_OR_CONST std::size_t block_size = deque_base::get_block_size();
+         return static_cast<size_type>(this->members_.m_start_off % block_size);
+      }
+   }
+
+   BOOST_CONTAINER_FORCEINLINE size_type prot_back_free_capacity() const
+   {
+      BOOST_CONSTEXPR_OR_CONST std::size_t block_size = deque_base::get_block_size();
+
+      BOOST_IF_CONSTEXPR(is_reservable){
+         return static_cast<size_type>
+            (size_type(this->members_.m_map_size*block_size) - size_type(this->members_.m_map != ptr_alloc_ptr()) - this->members_.m_finish_off);
+      }
+      else {
+         //m_finish_off points to positions [0....block_size-1], and one position is always needed as the sentinel node resulting [block_size-1....0] capacity
+         return static_cast<size_type>(this->members_.m_map ? (block_size - 1u) - (this->members_.m_finish_off % block_size) : 0u);
+      }
+   }
+
+   //////////////////////////
+   // it_to_off / off_to_it
+   //////////////////////////
+
+   BOOST_CONTAINER_FORCEINLINE stored_size_type prot_it_to_off(const_iterator it) const
+   {
+      const ptr_alloc_ptr n = it.get_node();
+      BOOST_ASSERT(!this->members_.m_map == !n);  //Both should be null or both non-null
+      if (n) {
+         BOOST_CONSTEXPR_OR_CONST std::size_t block_size = deque_base::get_block_size();
+         return static_cast<stored_size_type>(std::size_t(n - this->members_.m_map)*block_size + std::size_t(it.get_cur() - *n));
+      }
+      else{
+         return 0;
+      }
+   }
+
+   BOOST_CONTAINER_FORCEINLINE iterator prot_off_to_it(std::size_t off) const
+   {
+      BOOST_CONSTEXPR_OR_CONST std::size_t block_size  = deque_base::get_block_size();
+      const ptr_alloc_ptr node = this->members_.m_map + difference_type(off/block_size);
+      return iterator(node ? *node + difference_type(off%block_size) : val_alloc_ptr(), node);
+   }
+
+   stored_size_type prot_it_to_start_off(const_iterator it) const
+   {
+      const size_type off = this->prot_it_to_off(it);
+      BOOST_ASSERT(off >= this->members_.m_start_off);
+      return static_cast<stored_size_type>(off - this->members_.m_start_off);
+   }
+
+   /////////////
+   // xxx_to_node
+   /////////////
+
+   BOOST_CONTAINER_FORCEINLINE ptr_alloc_ptr prot_off_to_node(std::size_t off) const
+   {
+      BOOST_CONSTEXPR_OR_CONST std::size_t block_size  = deque_base::get_block_size();
+      return this->members_.m_map + difference_type(off/block_size);
+   }
+
+   BOOST_CONTAINER_FORCEINLINE ptr_alloc_ptr prot_start_node() const
+   {
+      return this->prot_off_to_node(this->members_.m_start_off);
+   }
+
+   BOOST_CONTAINER_FORCEINLINE ptr_alloc_ptr prot_finish_node() const
+   {
+      return this->prot_off_to_node(this->members_.m_finish_off);
+   }
+
+   //
+   //    xxx_to_cur_unchecked versions, faster but need non-default constructed deque
+   //
+   BOOST_CONTAINER_FORCEINLINE val_alloc_ptr prot_off_to_cur_unchecked(std::size_t off) const
+   {
+      BOOST_ASSERT(!!this->members_.m_map);
+      BOOST_CONSTEXPR_OR_CONST std::size_t block_size  = deque_base::get_block_size();
+      const ptr_alloc_ptr node = this->members_.m_map + difference_type(off/block_size);
+      return *node + difference_type(off%block_size);
+   }
+
+   BOOST_CONTAINER_FORCEINLINE val_alloc_ptr prot_start_cur_unchecked() const
+   {
+      return this->prot_off_to_cur_unchecked(this->members_.m_start_off);
+   }
+
+   BOOST_CONTAINER_FORCEINLINE val_alloc_ptr prot_finish_cur_unchecked() const
+   {
+      return this->prot_off_to_cur_unchecked(this->members_.m_finish_off);
+   }
+
+   BOOST_CONTAINER_FORCEINLINE val_alloc_ptr prot_last_cur_unchecked() const
+   {
+      BOOST_ASSERT(members_.m_start_off != members_.m_finish_off);
+      return this->prot_off_to_cur_unchecked(this->members_.m_finish_off-1u);
+   }
+
+   //
+   //    functions returning iterators to different positions
+   //
+   BOOST_CONTAINER_FORCEINLINE const_iterator prot_start() const
+   {  return this->prot_off_to_it(members_.m_start_off);  }
+
+   BOOST_CONTAINER_FORCEINLINE iterator prot_start()
+   {  return this->prot_off_to_it(members_.m_start_off);  }
+
+   BOOST_CONTAINER_FORCEINLINE const_iterator prot_finish() const
+   {  return this->prot_off_to_it(members_.m_finish_off);  }
+
+   BOOST_CONTAINER_FORCEINLINE iterator prot_finish()
+   {  return this->prot_off_to_it(members_.m_finish_off);  }
+
+   BOOST_CONTAINER_FORCEINLINE const_iterator prot_nth(size_type n) const
+   {  return this->prot_off_to_it(size_type(members_.m_start_off + n));  }
+
+   BOOST_CONTAINER_FORCEINLINE iterator prot_nth(size_type n)
+   {  return this->prot_off_to_it(size_type(members_.m_start_off + n));  }
+
+   BOOST_CONTAINER_FORCEINLINE iterator prot_back_it()
+   {
+      BOOST_ASSERT(members_.m_start_off != members_.m_finish_off);
+      return this->prot_off_to_it(size_type(members_.m_finish_off - 1u));
+   }
+
+   //
+   //  size/empty
+   //
+   BOOST_CONTAINER_FORCEINLINE size_type prot_size() const
+   {  return size_type(this->members_.m_finish_off - this->members_.m_start_off);  }
+
+   BOOST_CONTAINER_FORCEINLINE bool prot_empty() const
+   {  return this->members_.m_finish_off == this->members_.m_start_off;  }
+
+   //
+   //  Functions to move start/finish indexes
+   //
+   BOOST_CONTAINER_FORCEINLINE void prot_inc_start()
+   {  ++this->members_.m_start_off;  }
+
+   BOOST_CONTAINER_FORCEINLINE void prot_dec_start()
+   {  --this->members_.m_start_off;  }
+
+   BOOST_CONTAINER_FORCEINLINE void prot_inc_finish()
+   {  ++this->members_.m_finish_off;  }
+
+   BOOST_CONTAINER_FORCEINLINE void prot_dec_finish()
+   {  --this->members_.m_finish_off;  }
+
+   BOOST_CONTAINER_FORCEINLINE void prot_dec_finish(std::size_t n)
+   {  this->members_.m_finish_off = static_cast<stored_size_type>(this->members_.m_finish_off - n);  }
+
+   BOOST_CONTAINER_FORCEINLINE void prot_inc_finish(std::size_t n)
+   {  this->members_.m_finish_off = static_cast<stored_size_type>(this->members_.m_finish_off + n);  }
+
+   BOOST_CONTAINER_FORCEINLINE void prot_dec_start(std::size_t n)
+   {  this->members_.m_start_off = static_cast<stored_size_type>(this->members_.m_start_off - n);  }
+
+   BOOST_CONTAINER_FORCEINLINE void prot_inc_start(std::size_t n)
+   {  this->members_.m_start_off = static_cast<stored_size_type>(this->members_.m_start_off + n);  }
+
+   //
+   //  Functions to obtain indexes from nodes
+   //
+   BOOST_CONTAINER_FORCEINLINE stored_size_type prot_non_null_node_to_off(ptr_alloc_ptr n) const
+   {
+      BOOST_CONSTEXPR_OR_CONST std::size_t block_size  = deque_base::get_block_size();
+      return static_cast<stored_size_type>(std::size_t(n - this->members_.m_map)*block_size);
+   }
+
+   void prot_set_start_finish_from_node(size_type node_idx, size_type n_elements)
+   {
+      BOOST_CONSTEXPR_OR_CONST std::size_t block_size  = deque_base::get_block_size();
+      this->members_.m_start_off  = static_cast<stored_size_type>(node_idx*block_size);
+      this->members_.m_finish_off = static_cast<stored_size_type>(this->members_.m_start_off + n_elements);
+   }
+
+   inline void prot_start_update_node(ptr_alloc_ptr new_start)
+   {
+      //iG: to-do: optimizable avoiding some division/remainder
+      std::size_t new_block_off = prot_non_null_node_to_off(new_start);
+      this->members_.m_start_off = static_cast<stored_size_type>(new_block_off + (this->members_.m_start_off % get_block_size()));
+   }
+
+   inline void prot_finish_update_node(ptr_alloc_ptr new_finish)
+   {
+      //iG: to-do: optimizable avoiding some division/remainder
+      std::size_t new_block_off = prot_non_null_node_to_off(new_finish);
+      this->members_.m_finish_off = static_cast<stored_size_type>(new_block_off + (this->members_.m_finish_off % get_block_size()));
+   }
+
+   inline void prot_reset_finish_to_start()
+   {  this->members_.m_finish_off = this->members_.m_start_off;  }
+
+   inline void prot_reset_start_to_finish()
+   {  this->members_.m_start_off = this->members_.m_finish_off;  }
+
+   inline val_alloc_val *prot_push_back_simple_pos() const
+   {
+      BOOST_CONSTEXPR_OR_CONST std::size_t block_size  = deque_base::get_block_size();
+      const std::size_t last_in_block = block_size - 1u;
+      const ptr_alloc_val *const map = boost::movelib::to_raw_pointer(this->members_.m_map);
+      if(BOOST_LIKELY(map != 0)) {
+         const std::size_t off = this->members_.m_finish_off;
+         const std::size_t rem = off % block_size;
+         if(BOOST_LIKELY(rem != last_in_block)){
+            return boost::movelib::to_raw_pointer(map[difference_type(off/block_size)]) + difference_type(rem);
+         }
+      }
+      return 0;
+   }
+
+   inline val_alloc_val *prot_push_front_simple_pos() const
+   {
+      BOOST_CONSTEXPR_OR_CONST std::size_t block_size  = deque_base::get_block_size();
+      //No need to check !m_map, as m_start_off is zero in that case
+      const std::size_t off = this->members_.m_start_off;
+      const std::size_t rem = off % block_size;
+      if(BOOST_LIKELY(rem != 0u)){
+         return boost::movelib::to_raw_pointer(this->members_.m_map[difference_type(off/block_size)]) + difference_type(rem-1u);
+      }
+      return 0;
+   }
+
+   BOOST_CONTAINER_FORCEINLINE bool prot_pop_back_simple_available() const
+   {
+      return (this->members_.m_finish_off % get_block_size()) != 0u;
+   }
 
-   inline allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW
-   {  return members_;  }
+   BOOST_CONTAINER_FORCEINLINE bool prot_pop_front_simple_available() const
+   {
+      return size_type(this->members_.m_start_off % get_block_size()) != size_type(get_block_size() - 1u);
+   }
 
-   inline const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return members_;  }
 };
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -1032,8 +1065,9 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    BOOST_CONTAINER_STATIC_ASSERT((dtl::is_same<value_type, typename allocator_traits<ValAllocator>::value_type>::value));
 
    BOOST_COPYABLE_AND_MOVABLE(deque)
-   typedef typename Base::ptr_alloc_ptr index_pointer;
-   typedef allocator_traits<ValAllocator>                  allocator_traits_type;
+   typedef typename Base::ptr_alloc_ptr                     index_pointer;
+   typedef allocator_traits<ValAllocator>                   allocator_traits_type;
+   typedef typename Base::stored_size_type                  stored_size_type;
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -1043,6 +1077,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
 
    using Base::get_block_size;
 
+   static const std::size_t is_reservable = Base::is_reservable;
 
    //////////////////////////////////////////////
    //
@@ -1080,7 +1115,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       : Base(n, allocator_type())
    {
       dtl::insert_value_initialized_n_proxy<ValAllocator> proxy;
-      proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
+      this->priv_segmented_proxy_uninitialized_copy_n_and_update(this->begin(), n, proxy);
       //deque_base will deallocate in case of exception...
    }
 
@@ -1097,7 +1132,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       : Base(n, allocator_type())
    {
       dtl::insert_default_initialized_n_proxy<ValAllocator> proxy;
-      proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
+      this->priv_segmented_proxy_uninitialized_copy_n_and_update(this->begin(), n, proxy);
       //deque_base will deallocate in case of exception...
    }
 
@@ -1112,7 +1147,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       : Base(n, a)
    {
       dtl::insert_value_initialized_n_proxy<ValAllocator> proxy;
-      proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
+      this->priv_segmented_proxy_uninitialized_copy_n_and_update(this->begin(), n, proxy);
       //deque_base will deallocate in case of exception...
    }
 
@@ -1129,7 +1164,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       : Base(n, a)
    {
       dtl::insert_default_initialized_n_proxy<ValAllocator> proxy;
-      proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
+      this->priv_segmented_proxy_uninitialized_copy_n_and_update(this->begin(), n, proxy);
       //deque_base will deallocate in case of exception...
    }
 
@@ -1142,7 +1177,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to n.
    inline deque(size_type n, const value_type& value)
       : Base(n, allocator_type())
-   { this->priv_fill_initialize(value); }
+   { this->priv_fill_initialize(n, value); }
 
    //! <b>Effects</b>: Constructs a deque that will use a copy of allocator a
    //!   and inserts n copies of value.
@@ -1153,7 +1188,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to n.
    inline deque(size_type n, const value_type& value, const allocator_type& a)
       : Base(n, a)
-   { this->priv_fill_initialize(value); }
+   { this->priv_fill_initialize(n, value); }
 
    //! <b>Effects</b>: Constructs a deque that will use a copy of allocator a
    //!   and inserts a copy of the range [first, last) in the deque.
@@ -1217,9 +1252,8 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       :  Base(allocator_traits_type::select_on_container_copy_construction(x.alloc()))
    {
       if(x.size()){
-         this->priv_initialize_map(x.size());
-         boost::container::uninitialized_copy_alloc
-            (this->alloc(), x.begin(), x.end(), this->members_.m_start);
+         this->prot_initialize_map_and_nodes(x.size());
+         this->priv_segmented_uninitialized_copy_alloc_n(x.begin(), x.size(), this->begin());
       }
    }
 
@@ -1244,9 +1278,8 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       :  Base(a)
    {
       if(x.size()){
-         this->priv_initialize_map(x.size());
-         boost::container::uninitialized_copy_alloc
-            (this->alloc(), x.begin(), x.end(), this->members_.m_start);
+         this->prot_initialize_map_and_nodes(x.size());
+         this->priv_segmented_uninitialized_copy_alloc_n(x.begin(), x.size(), this->begin());
       }
    }
 
@@ -1265,10 +1298,8 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       }
       else{
          if(x.size()){
-            this->priv_initialize_map(x.size());
-            boost::container::uninitialized_copy_alloc
-               ( this->alloc(), boost::make_move_iterator(x.begin())
-               , boost::make_move_iterator(x.end()), this->members_.m_start);
+            this->prot_initialize_map_and_nodes(x.size());
+            this->priv_segmented_uninitialized_move_alloc_n(x.begin(), x.size(), this->begin());
          }
       }
    }
@@ -1281,7 +1312,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to the number of elements.
    inline ~deque() BOOST_NOEXCEPT_OR_NOTHROW
    {
-      this->priv_destroy_range(this->members_.m_start, this->members_.m_finish);
+      this->prot_destroy_range(this->prot_start(), this->prot_finish());
    }
 
    //! <b>Effects</b>: Makes *this contain the same elements as x.
@@ -1357,7 +1388,8 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to n.
    inline void assign(size_type n, const T& val)
    {
-      this->assign(c_it(val, n), c_it());
+      dtl::insert_n_copies_proxy<ValAllocator> proxy(val);
+      this->priv_assign(n, proxy);
    }
 
    //! <b>Effects</b>: Assigns the the range [first, last) to *this.
@@ -1399,16 +1431,14 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          >::type * = 0
       )
    {
-      const size_type len = boost::container::iterator_udistance(first, last);
-      if (len > size()) {
-         FwdIt mid = first;
-         boost::container::iterator_uadvance(mid, this->size());
-         boost::container::copy(first, mid, begin());
-         this->insert(this->cend(), mid, last);
-      }
-      else{
-         this->erase(boost::container::copy(first, last, this->begin()), cend());
+      typedef typename iter_size<FwdIt>::type it_size_type;
+      const it_size_type sz = boost::container::iterator_udistance(first, last);
+      if (BOOST_UNLIKELY(sz > size_type(-1))){
+         boost::container::throw_length_error("vector::insert, FwdIt's max length reached");
       }
+      const size_type n = static_cast<size_type>(sz);
+      dtl::insert_range_proxy<ValAllocator, FwdIt> proxy(first);
+      this->priv_assign(n, proxy);
    }
    #endif
 
@@ -1467,7 +1497,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
-      { return this->members_.m_start; }
+      { return this->prot_start(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the deque.
    //!
@@ -1476,7 +1506,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return this->members_.m_start; }
+      { return this->prot_start(); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the deque.
    //!
@@ -1485,7 +1515,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator end() BOOST_NOEXCEPT_OR_NOTHROW
-      { return this->members_.m_finish; }
+      { return this->prot_finish(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the deque.
    //!
@@ -1494,7 +1524,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return this->members_.m_finish; }
+      { return this->prot_finish(); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
    //! of the reversed deque.
@@ -1504,7 +1534,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
-      { return reverse_iterator(this->members_.m_finish); }
+      { return reverse_iterator(this->prot_finish()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
    //! of the reversed deque.
@@ -1514,7 +1544,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return const_reverse_iterator(this->members_.m_finish); }
+      { return const_reverse_iterator(this->prot_finish()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
    //! of the reversed deque.
@@ -1524,7 +1554,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
-      { return reverse_iterator(this->members_.m_start); }
+      { return reverse_iterator(this->prot_start()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
    //! of the reversed deque.
@@ -1534,7 +1564,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return const_reverse_iterator(this->members_.m_start); }
+      { return const_reverse_iterator(this->prot_start()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the deque.
    //!
@@ -1543,7 +1573,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return this->members_.m_start; }
+      { return this->prot_start(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the deque.
    //!
@@ -1552,7 +1582,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return this->members_.m_finish; }
+      { return this->prot_finish(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
    //! of the reversed deque.
@@ -1562,7 +1592,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return const_reverse_iterator(this->members_.m_finish); }
+      { return const_reverse_iterator(this->prot_finish()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
    //! of the reversed deque.
@@ -1572,7 +1602,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return const_reverse_iterator(this->members_.m_start); }
+      { return const_reverse_iterator(this->prot_start()); }
 
    //////////////////////////////////////////////
    //
@@ -1587,7 +1617,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
-   { return this->members_.m_finish == this->members_.m_start; }
+   { return this->prot_empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the deque.
    //!
@@ -1596,7 +1626,75 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return size_type(this->members_.m_finish - this->members_.m_start); }
+      { return this->prot_size(); }
+
+   //! <b>Effects</b>: Returns the number of the elements that can be inserted
+   //!   at the back without allocating additional memory.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+      size_type back_capacity() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return size_type(this->size() + this->prot_back_free_capacity()); }
+
+   //! <b>Effects</b>: Returns the number of the elements that can be inserted
+   //!   at the front without allocating additional memory.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+      size_type front_capacity() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return size_type(this->size() + this->prot_front_free_capacity()); }
+
+   //! <b>Requires</b>: The container must be "reservable" (is_reservable == true)
+   //!
+   //! <b>Effects</b>: If n is less than or equal to back_capacity() or the container is not reservable,
+   //!   this call has no effect. Otherwise, if it is a request for allocation of additional memory.
+   //!   If the request is successful, then back_capacity() is greater than or equal to
+   //!   n; otherwise, back_capacity() is unchanged. In either case, size() is unchanged.
+   //!
+   //! <b>Throws</b>: If memory allocation throws.
+   //!
+   //! <b>Complexity</b>: Linear to n.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   void reserve_back(size_type n)
+   {
+      (void)n;
+      BOOST_IF_CONSTEXPR(is_reservable){
+         const size_type cur_back_cap = this->back_capacity();
+         if (this->back_capacity() < n)
+            this->priv_reserve_elements_at_back(size_type(n - cur_back_cap) );
+      }
+   }
+
+   //! <b>Requires</b>: The container must be "reservable" (is_reservable == true)
+   //!
+   //! <b>Effects</b>: If n is less than or equal to back_capacity() or the container is not reservable,
+   //!   this call has no effect. Otherwise, if it is a request for allocation of additional memory.
+   //!   If the request is successful, then back_capacity() is greater than or equal to
+   //!   n; otherwise, back_capacity() is unchanged. In either case, size() is unchanged.
+   //!
+   //! <b>Throws</b>: If memory allocation throws.
+   //!
+   //! <b>Complexity</b>: Linear to n.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   void reserve_front(size_type n)
+   {
+      (void)n;
+      BOOST_IF_CONSTEXPR(is_reservable){
+         const size_type cur_back_cap = this->front_capacity();
+         if (this->front_capacity() < n)
+            this->priv_reserve_elements_at_front(size_type(n - cur_back_cap) );
+      }
+   }
 
    //! <b>Effects</b>: Returns the largest possible size of the deque.
    //!
@@ -1615,13 +1713,13 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
    void resize(size_type new_size)
    {
-      const size_type len = size();
+      const size_type len = this->size();
       if (new_size < len)
-         this->priv_erase_last_n(len - new_size);
+         this->priv_erase_last_n(size_type(len - new_size));
       else{
-         const size_type n = new_size - this->size();
+         const size_type n = size_type(new_size - this->size());
          dtl::insert_value_initialized_n_proxy<ValAllocator> proxy;
-         priv_insert_back_aux_impl(n, proxy);
+         this->priv_insert_back_aux_impl(n, proxy);
       }
    }
 
@@ -1637,11 +1735,11 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    {
       const size_type len = size();
       if (new_size < len)
-         this->priv_erase_last_n(len - new_size);
+         this->priv_erase_last_n(size_type(len - new_size));
       else{
-         const size_type n = new_size - this->size();
+         const size_type n = size_type(new_size - this->size());
          dtl::insert_default_initialized_n_proxy<ValAllocator> proxy;
-         priv_insert_back_aux_impl(n, proxy);
+         this->priv_insert_back_aux_impl(n, proxy);
       }
    }
 
@@ -1653,11 +1751,14 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
    void resize(size_type new_size, const value_type& x)
    {
-      const size_type len = size();
-      if (new_size < len)
-         this->erase(this->members_.m_start + difference_type(new_size), this->members_.m_finish);
-      else
-         this->insert(this->members_.m_finish, new_size - len, x);
+      const size_type sz = this->size();
+      if (new_size < sz)
+         this->priv_erase_last_n(size_type(sz - new_size));
+      else {
+         const size_type n = size_type(new_size - sz);
+         dtl::insert_n_copies_proxy<ValAllocator> proxy(x);
+         this->priv_insert_back_aux_impl(n, proxy);
+      }
    }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
@@ -1673,7 +1774,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       //so there is nothing to do except for
       //empty deque
       if(this->empty()){
-         this->priv_clear_map();
+         this->prot_clear_map();
       }
    }
 
@@ -1695,7 +1796,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       reference front() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
-      return *this->members_.m_start;
+      return *this->prot_start_cur_unchecked();
    }
 
    //! <b>Requires</b>: !empty()
@@ -1710,7 +1811,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       const_reference front() const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
-      return *this->members_.m_start;
+      return *this->prot_start_cur_unchecked();
    }
 
    //! <b>Requires</b>: !empty()
@@ -1725,7 +1826,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       reference back() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
-      return *(end()-1);
+      return *this->prot_last_cur_unchecked();
    }
 
    //! <b>Requires</b>: !empty()
@@ -1740,7 +1841,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       const_reference back() const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
-      return *(cend()-1);
+      return *this->prot_last_cur_unchecked();
    }
 
    //! <b>Requires</b>: size() > n.
@@ -1755,7 +1856,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() > n);
-      return this->members_.m_start[difference_type(n)];
+      return *this->prot_nth(n);
    }
 
    //! <b>Requires</b>: size() > n.
@@ -1770,7 +1871,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       const_reference operator[](size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() > n);
-      return this->members_.m_start[difference_type(n)];
+      return *this->prot_nth(n);
    }
 
    //! <b>Requires</b>: size() >= n.
@@ -1788,7 +1889,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() >= n);
-      return iterator(this->begin()+difference_type(n));
+      return this->prot_nth(n);
    }
 
    //! <b>Requires</b>: size() >= n.
@@ -1806,7 +1907,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() >= n);
-      return const_iterator(this->cbegin()+difference_type(n));
+      return this->prot_nth(n);
    }
 
    //! <b>Requires</b>: begin() <= p <= end().
@@ -1892,14 +1993,14 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    template <class... Args>
    reference emplace_front(BOOST_FWD_REF(Args)... args)
    {
-      if(this->priv_push_front_simple_available()){
-         reference r = *this->priv_push_front_simple_pos();
+      value_type *pr = this->prot_push_front_simple_pos();
+      if(BOOST_LIKELY(pr != 0)){
          allocator_traits_type::construct
             ( this->alloc()
-            , this->priv_push_front_simple_pos()
+            , pr
             , boost::forward<Args>(args)...);
-         this->priv_push_front_simple_commit();
-         return r;
+         this->prot_dec_start();
+         return *pr;
       }
       else{
          typedef dtl::insert_nonmovable_emplace_proxy<ValAllocator, Args...> type;
@@ -1918,14 +2019,12 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    template <class... Args>
    reference emplace_back(BOOST_FWD_REF(Args)... args)
    {
-      if(this->priv_push_back_simple_available()){
-         reference r = *this->priv_push_back_simple_pos();
+      value_type *pr = this->prot_push_back_simple_pos();
+      if(BOOST_LIKELY(pr != 0)){
          allocator_traits_type::construct
-            ( this->alloc()
-            , this->priv_push_back_simple_pos()
-            , boost::forward<Args>(args)...);
-         this->priv_push_back_simple_commit();
-         return r;
+            ( this->alloc(), pr, boost::forward<Args>(args)...);
+         this->prot_inc_finish();
+         return *pr;
       }
       else{
          typedef dtl::insert_nonmovable_emplace_proxy<ValAllocator, Args...> type;
@@ -1945,18 +2044,20 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    template <class... Args>
    iterator emplace(const_iterator p, BOOST_FWD_REF(Args)... args)
    {
-      BOOST_ASSERT(this->priv_in_range_or_end(p));
-      if(p == this->cbegin()){
+      const size_type elemsbefore = this->prot_it_to_start_off(p);
+      const size_type length      = this->prot_size();
+
+      if (!elemsbefore) {
          this->emplace_front(boost::forward<Args>(args)...);
          return this->begin();
       }
-      else if(p == this->cend()){
+      else if (elemsbefore == length) {
          this->emplace_back(boost::forward<Args>(args)...);
-         return (this->end()-1);
+         return this->prot_back_it();
       }
-      else{
+      else {
          typedef dtl::insert_emplace_proxy<ValAllocator, Args...> type;
-         return this->priv_insert_aux_impl(p, 1, type(boost::forward<Args>(args)...));
+         return this->priv_insert_middle_aux_impl(elemsbefore, 1, type(boost::forward<Args>(args)...));
       }
    }
 
@@ -1966,12 +2067,12 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\
    reference emplace_front(BOOST_MOVE_UREF##N)\
    {\
-      if(priv_push_front_simple_available()){\
-         reference r = *this->priv_push_front_simple_pos();\
+      value_type *pr = this->prot_push_front_simple_pos();\
+      if(BOOST_LIKELY(pr != 0)){\
          allocator_traits_type::construct\
-            ( this->alloc(), this->priv_push_front_simple_pos() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-         priv_push_front_simple_commit();\
-         return r;\
+            ( this->alloc(), pr BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         this->prot_dec_start();\
+         return *pr;\
       }\
       else{\
          typedef dtl::insert_nonmovable_emplace_proxy##N\
@@ -1983,12 +2084,12 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\
    reference emplace_back(BOOST_MOVE_UREF##N)\
    {\
-      if(priv_push_back_simple_available()){\
-         reference r = *this->priv_push_back_simple_pos();\
+      value_type *pr = this->prot_push_back_simple_pos();\
+      if(BOOST_LIKELY(pr != 0)){\
          allocator_traits_type::construct\
-            ( this->alloc(), this->priv_push_back_simple_pos() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-         priv_push_back_simple_commit();\
-         return r;\
+            ( this->alloc(), pr BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         this->prot_inc_finish();\
+         return *pr;\
       }\
       else{\
          typedef dtl::insert_nonmovable_emplace_proxy##N\
@@ -2000,21 +2101,23 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N\
    iterator emplace(const_iterator p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
-      BOOST_ASSERT(this->priv_in_range_or_end(p));\
-      if(p == this->cbegin()){\
+      const size_type elemsbefore = this->prot_it_to_start_off(p);\
+      const size_type length      = this->prot_size();\
+      \
+      if (!elemsbefore) {\
          this->emplace_front(BOOST_MOVE_FWD##N);\
          return this->begin();\
       }\
-      else if(p == cend()){\
+      else if (elemsbefore == length) {\
          this->emplace_back(BOOST_MOVE_FWD##N);\
-         return (--this->end());\
+         return this->prot_back_it();\
       }\
-      else{\
+      else {\
          typedef dtl::insert_emplace_proxy_arg##N\
                <ValAllocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
-         return this->priv_insert_aux_impl(p, 1, type(BOOST_MOVE_FWD##N));\
+         return this->priv_insert_middle_aux_impl(elemsbefore, 1, type(BOOST_MOVE_FWD##N));\
       }\
-   }
+   }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DEQUE_EMPLACE_CODE)
    #undef BOOST_CONTAINER_DEQUE_EMPLACE_CODE
@@ -2101,8 +2204,9 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to n.
    inline iterator insert(const_iterator pos, size_type n, const value_type& x)
    {
-      //Range check of p is done by insert()
-      return this->insert(pos, c_it(x, n), c_it());
+      BOOST_ASSERT(this->priv_in_range_or_end(pos));
+      dtl::insert_n_copies_proxy<ValAllocator> proxy(x);
+      return this->priv_insert_aux_impl(pos, n, proxy);
    }
 
    //! <b>Requires</b>: pos must be a valid iterator of *this.
@@ -2168,8 +2272,16 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       )
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
+
+      typedef typename iter_size<FwdIt>::type it_size_type;
+      const it_size_type sz = boost::container::iterator_udistance(first, last);
+      if (BOOST_UNLIKELY(sz > size_type(-1))){
+         boost::container::throw_length_error("vector::insert, FwdIt's max length reached");
+      }
+      const size_type n = static_cast<size_type>(sz);
+
       dtl::insert_range_proxy<ValAllocator, FwdIt> proxy(first);
-      return priv_insert_aux_impl(p, boost::container::iterator_udistance(first, last), proxy);
+      return this->priv_insert_aux_impl( p, n, proxy);
    }
    #endif
 
@@ -2181,12 +2293,12 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    void pop_front() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
-      if (this->members_.m_start.m_cur != this->members_.m_start.get_last() - 1) {
+      if (BOOST_LIKELY(this->prot_pop_front_simple_available())) {
          allocator_traits_type::destroy
             ( this->alloc()
-            , boost::movelib::to_raw_pointer(this->members_.m_start.m_cur)
+            , boost::movelib::to_raw_pointer(this->prot_start_cur_unchecked())
             );
-         ++this->members_.m_start.m_cur;
+         this->prot_inc_start();
       }
       else
          this->priv_pop_front_aux();
@@ -2200,11 +2312,11 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    void pop_back() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
-      if (this->members_.m_finish.m_cur != this->members_.m_finish.get_first()) {
-         --this->members_.m_finish.m_cur;
+      if (BOOST_LIKELY(this->prot_pop_back_simple_available())) {
+         this->prot_dec_finish();
          allocator_traits_type::destroy
             ( this->alloc()
-            , boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur)
+            , boost::movelib::to_raw_pointer(this->prot_finish_cur_unchecked())
             );
       }
       else
@@ -2224,16 +2336,18 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       BOOST_ASSERT(this->priv_in_range(pos));
       iterator next = pos.unconst();
       ++next;
-      size_type index = size_type(pos - this->members_.m_start);
-      if (index < (this->size()/2)) {
-         boost::container::move_backward(this->begin(), pos.unconst(), next);
+      const size_type index = this->prot_it_to_start_off(pos);
+      const size_type sz    = this->prot_size();
+      if (index < sz/2u) {
+         this->priv_segmented_move_backward_n(pos.unconst(), index, next);
          pop_front();
+         return next;
       }
       else {
-         boost::container::move(next, this->end(), pos.unconst());
+         this->priv_segmented_move_n(next, size_type(sz - size_type(index + 1u)), pos.unconst());
          pop_back();
+         return pos.unconst();
       }
-      return this->members_.m_start + difference_type(index);
    }
 
    //! <b>Effects</b>: Erases the elements pointed by [first, last).
@@ -2248,28 +2362,29 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    {
       BOOST_ASSERT(first == last ||
          (first < last && this->priv_in_range(first) && this->priv_in_range_or_end(last)));
-      if (first == this->members_.m_start && last == this->members_.m_finish) {
+      const size_type n = static_cast<size_type>(last - first);
+      if (n == this->prot_size()) {
          this->clear();
-         return this->members_.m_finish;
+         return this->end();
       }
       else {
-         const size_type n = static_cast<size_type>(last - first);
-         const size_type elems_before = static_cast<size_type>(first - this->members_.m_start);
-         if (elems_before < (this->size() - n) - elems_before) {
-            boost::container::move_backward(begin(), first.unconst(), last.unconst());
-            iterator new_start = this->members_.m_start + difference_type(n);
-            this->priv_destroy_range(this->members_.m_start, new_start);
-            this->priv_destroy_nodes(this->members_.m_start.m_node, new_start.m_node);
-            this->members_.m_start = new_start;
+         const size_type elems_before = this->prot_it_to_start_off(first);
+         const size_type elems_after  = size_type(this->prot_size() - n - elems_before);
+         if (elems_before < elems_after) {
+            const iterator old_start = this->begin();
+            iterator new_start = this->priv_segmented_move_backward_n(first.unconst(), elems_before, last.unconst());
+            this->prot_destroy_range(old_start, new_start);
+            this->prot_deallocate_nodes_if_not_reservable(old_start.get_node(), new_start.m_node);
+            this->prot_inc_start(n);
          }
          else {
-            boost::container::move(last.unconst(), end(), first.unconst());
-            iterator new_finish = this->members_.m_finish - difference_type(n);
-            this->priv_destroy_range(new_finish, this->members_.m_finish);
-            this->priv_destroy_nodes(new_finish.m_node + 1, this->members_.m_finish.m_node + 1);
-            this->members_.m_finish = new_finish;
+            const iterator old_finish = this->end();
+            iterator new_finish = this->priv_segmented_move_n(last.unconst(), elems_after, first.unconst());
+            this->prot_destroy_range(new_finish, old_finish);
+            this->prot_deallocate_nodes_if_not_reservable(new_finish.m_node + 1, old_finish.get_node() + 1);
+            this->prot_dec_finish(n);
          }
-         return this->members_.m_start + difference_type(elems_before);
+         return this->nth(elems_before);
       }
    }
 
@@ -2295,24 +2410,25 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to the number of elements in the deque.
    void clear() BOOST_NOEXCEPT_OR_NOTHROW
    {
-      if (this->members_.m_finish != this->members_.m_start) {
-  
-         for (index_pointer node = this->members_.m_start.m_node + 1;
-               node < this->members_.m_finish.m_node;
-               ++node) {
-            this->priv_destroy_range(*node, *node + get_block_ssize());
-            this->priv_deallocate_node(*node);
+      if (!this->empty()) {
+         const iterator start = this->prot_start();
+         const iterator finish = this->prot_finish();
+         const index_pointer start_node =  start.get_node();
+         const index_pointer finish_node = finish.get_node();
+         for (index_pointer node = start_node + 1; node < finish_node; ++node) {
+            this->prot_destroy_range(*node, *node + get_block_ssize());
+            this->prot_deallocate_node_if_not_reservable(*node);
          }
 
-         if (this->members_.m_start.m_node != this->members_.m_finish.m_node) {
-            this->priv_destroy_range(this->members_.m_start.m_cur, this->members_.m_start.get_last());
-            this->priv_destroy_range(this->members_.m_finish.get_first(), this->members_.m_finish.m_cur);
-            this->priv_deallocate_node(this->members_.m_finish.get_first());
+         if (start_node != finish_node) {
+            this->prot_destroy_range(start.get_cur(), start.get_last());
+            this->prot_destroy_range(finish.get_first(), finish.get_cur());
+            this->prot_deallocate_node_if_not_reservable(finish.get_first());
          }
          else
-            this->priv_destroy_range(this->members_.m_start.m_cur, this->members_.m_finish.m_cur);
+            this->prot_destroy_range(start.get_cur(), finish.get_cur());
 
-         this->members_.m_finish = this->members_.m_start;
+         this->prot_reset_finish_to_start();
       }
    }
 
@@ -2368,6 +2484,19 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
 
+   template <class InsertProxy>
+   void priv_assign(size_type n, InsertProxy proxy)
+   {
+      const size_type sz  = this->prot_size();
+      this->priv_segmented_proxy_copy_n_and_update(this->begin(), sz < n ? sz : n, proxy);
+      if (n > sz) {
+         this->priv_insert_back_aux_impl(size_type(n - sz), proxy);
+      }
+      else{
+         this->priv_erase_last_n(size_type(sz - n));
+      }
+   }
+
    void priv_move_assign(BOOST_RV_REF(deque) x, dtl::bool_<true> /*steal_resources*/)
    {
       //Destroy objects but retain memory in case x reuses it in the future
@@ -2396,19 +2525,20 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    {
       BOOST_ASSERT(this->cbegin() <= p);
       BOOST_ASSERT(p <= this->cend());
-      return static_cast<size_type>(p - this->cbegin());
+      return this->prot_it_to_start_off(p);
    }
 
    void priv_erase_last_n(size_type n)
    {
-      if(n == this->size()) {
-         this->clear();
-      }
-      else {
-         iterator new_finish = this->members_.m_finish - difference_type(n);
-         this->priv_destroy_range(new_finish, this->members_.m_finish);
-         this->priv_destroy_nodes(new_finish.m_node + 1, this->members_.m_finish.m_node + 1);
-         this->members_.m_finish = new_finish;
+      const size_type sz = this->prot_size();
+      BOOST_ASSERT(n <= sz);
+
+      if(sz) {
+         const iterator old_finish = this->prot_finish();
+         const iterator new_finish = old_finish - difference_type(n);
+         this->prot_destroy_range(new_finish, old_finish);
+         this->prot_deallocate_nodes_if_not_reservable(new_finish.get_node() + 1, old_finish.get_node() + 1);
+         this->prot_dec_finish(n);
       }
    }
 
@@ -2429,93 +2559,48 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    }
 
    template <class U>
-   iterator priv_insert(const_iterator p, BOOST_FWD_REF(U) x)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator p, BOOST_FWD_REF(U) x)
    {
-      BOOST_ASSERT(this->priv_in_range_or_end(p));
-      if (p == cbegin()){
-         this->push_front(::boost::forward<U>(x));
-         return begin();
-      }
-      else if (p == cend()){
-         this->push_back(::boost::forward<U>(x));
-         return --end();
-      }
-      else {
-         return priv_insert_aux_impl
-            ( p, (size_type)1
-            , dtl::get_insert_value_proxy<iterator, ValAllocator>(::boost::forward<U>(x)));
-      }
+      return this->emplace(p, ::boost::forward<U>(x));
    }
 
    template <class U>
-   void priv_push_front(BOOST_FWD_REF(U) x)
+   BOOST_CONTAINER_FORCEINLINE void priv_push_back(BOOST_FWD_REF(U) u)
    {
-      if(this->priv_push_front_simple_available()){
-         allocator_traits_type::construct
-            ( this->alloc(), this->priv_push_front_simple_pos(), ::boost::forward<U>(x));
-         this->priv_push_front_simple_commit();
-      }
-      else{
-         priv_insert_aux_impl
-            ( this->cbegin(), (size_type)1
-            , dtl::get_insert_value_proxy<iterator, ValAllocator>(::boost::forward<U>(x)));
-      }
+      this->emplace_back(::boost::forward<U>(u));
    }
 
    template <class U>
-   void priv_push_back(BOOST_FWD_REF(U) x)
-   {
-      if(this->priv_push_back_simple_available()){
-         allocator_traits_type::construct
-            ( this->alloc(), this->priv_push_back_simple_pos(), ::boost::forward<U>(x));
-         this->priv_push_back_simple_commit();
-      }
-      else{
-         priv_insert_aux_impl
-            ( this->cend(), (size_type)1
-            , dtl::get_insert_value_proxy<iterator, ValAllocator>(::boost::forward<U>(x)));
-      }
-   }
-
-   inline bool priv_push_back_simple_available() const
-   {
-      return this->members_.m_map &&
-         (this->members_.m_finish.m_cur != (this->members_.m_finish.get_last() - 1));
-   }
-
-   inline T *priv_push_back_simple_pos() const
-   {
-      return boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur);
-   }
-
-   inline void priv_push_back_simple_commit()
+   BOOST_CONTAINER_FORCEINLINE void priv_push_front(BOOST_FWD_REF(U) u)
    {
-      ++this->members_.m_finish.m_cur;
+      this->emplace_front(::boost::forward<U>(u));
    }
 
-   inline bool priv_push_front_simple_available() const
-   {
-      return this->members_.m_map &&
-         (this->members_.m_start.m_cur != this->members_.m_start.get_first());
-   }
-
-   inline T *priv_push_front_simple_pos() const
-   {  return boost::movelib::to_raw_pointer(this->members_.m_start.m_cur) - 1;  }
-
-   inline void priv_push_front_simple_commit()
-   {  --this->members_.m_start.m_cur;   }
-
-   void priv_destroy_range(iterator p, iterator p2)
+   void prot_destroy_range(iterator start, iterator finish)
    {
-      (void)p; (void)p2;
+      (void)start; (void)finish;
       BOOST_IF_CONSTEXPR(!Base::traits_t::trivial_dctr){
-         for(;p != p2; ++p){
-            allocator_traits_type::destroy(this->alloc(), boost::movelib::iterator_to_raw_pointer(p));
+         const index_pointer start_node =  start.get_node();
+         const index_pointer finish_node = finish.get_node();
+      
+         //In a sane deque both should be null or non-null
+         BOOST_ASSERT(!start_node == !finish_node);
+         if(start_node){
+            for (index_pointer node = start_node + 1; node < finish_node; ++node) {
+               this->prot_destroy_range(*node, *node + get_block_ssize());
+            }
+
+            if (start_node != finish_node) {
+               this->prot_destroy_range(start.get_cur(), start.get_last());
+               this->prot_destroy_range(finish.get_first(), finish.get_cur());
+            }
+            else
+               this->prot_destroy_range(start.get_cur(), finish.get_cur());
          }
       }
    }
 
-   void priv_destroy_range(pointer p, pointer p2)
+   void prot_destroy_range(pointer p, pointer p2)
    {
       (void)p; (void)p2;
       BOOST_IF_CONSTEXPR(!Base::traits_t::trivial_dctr){
@@ -2526,187 +2611,364 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    }
 
    template<class InsertProxy>
-   iterator priv_insert_middle_aux_impl(const_iterator p, const size_type elemsbefore, const size_type length, const size_type n, InsertProxy proxy)
+   iterator priv_insert_middle_aux_impl(const size_type elemsbefore, const size_type n, InsertProxy proxy)
    {
-      if (!this->members_.m_map) {
-         this->priv_initialize_map(0);
-         p = this->cbegin();
-      }
-
-      iterator pos(p.unconst());
-      const size_type pos_n = size_type(p - this->cbegin());
+      typedef dtl::bool_<dtl::is_single_value_proxy<InsertProxy>::value> single_t;
+      BOOST_ASSERT(!single_t::value || n == 1);
 
+      const size_type length = this->prot_size();
       if (elemsbefore < length / 2) {
-         const iterator new_start = this->priv_reserve_elements_at_front(n);
-         const iterator old_start = this->members_.m_start;
-         pos = this->members_.m_start + difference_type(elemsbefore);
-         if (elemsbefore >= n) {
-            const iterator start_n = this->members_.m_start + difference_type(n);
+         this->priv_reserve_elements_at_front(n);
+         const iterator old_start = this->prot_start();
+         iterator new_start = old_start;
+         priv_itsub(new_start, n, single_t());
+
+         BOOST_ASSERT(!single_t::value || elemsbefore >= 1);
+
+         if(single_t::value || elemsbefore >= n) {
+            iterator start_n = old_start;
+            priv_itadd(start_n, n, single_t());
             BOOST_CONTAINER_TRY {
-               ::boost::container::uninitialized_move_alloc
-                  (this->alloc(), this->members_.m_start, start_n, new_start);
+               this->priv_segmented_uninitialized_move_alloc_n(old_start, n, new_start, single_t());
             }
             BOOST_CONTAINER_CATCH(...) {
-               this->priv_destroy_nodes(new_start.m_node, this->members_.m_start.m_node);
+               this->prot_deallocate_nodes_if_not_reservable(new_start.m_node, old_start.m_node);
                BOOST_CONTAINER_RETHROW
             }
             BOOST_CONTAINER_CATCH_END
-            this->members_.m_start = new_start;
-            boost::container::move(start_n, pos, old_start);
-            proxy.copy_n_and_update(this->alloc(), pos - difference_type(n), n);
+
+            this->prot_dec_start(n);
+            iterator p = this->priv_segmented_move_n(start_n, size_type(elemsbefore - n), old_start);
+            this->priv_segmented_proxy_copy_n_and_update(p, n, proxy);
+            return p;
          }
          else {
-            const size_type mid_count = n - elemsbefore;
-            const iterator mid_start = old_start - difference_type(mid_count);
+            const size_type mid_count = size_type(n - elemsbefore);
+            iterator mid_start = old_start - difference_type(mid_count);
+
             BOOST_CONTAINER_TRY {
-               proxy.uninitialized_copy_n_and_update(this->alloc(), mid_start, mid_count);
-               this->members_.m_start = mid_start;
-               ::boost::container::uninitialized_move_alloc(this->alloc(), old_start, pos, new_start);
+               this->priv_segmented_proxy_uninitialized_copy_n_and_update(mid_start, mid_count, proxy);
+               this->prot_dec_start(mid_count);
+               this->priv_segmented_uninitialized_move_alloc_n(old_start, elemsbefore, new_start);
             }
             BOOST_CONTAINER_CATCH(...) {
-               this->priv_destroy_nodes(new_start.m_node, this->members_.m_start.m_node);
+               this->prot_deallocate_nodes_if_not_reservable(new_start.m_node, old_start.get_node());
                BOOST_CONTAINER_RETHROW
             }
             BOOST_CONTAINER_CATCH_END
-            this->members_.m_start = new_start;
-            proxy.copy_n_and_update(this->alloc(), old_start, elemsbefore);
+            this->prot_dec_start(size_type(n - mid_count));
+            this->priv_segmented_proxy_copy_n_and_update(old_start, elemsbefore, proxy);
+            return mid_start;
          }
       }
       else {
-         const iterator new_finish = this->priv_reserve_elements_at_back(n);
-         const iterator old_finish = this->members_.m_finish;
-         const size_type elemsafter = length - elemsbefore;
+         this->priv_reserve_elements_at_back(n);
+         const iterator old_finish  = this->prot_finish();
+         const size_type elemsafter = size_type(length - elemsbefore);
+
+         BOOST_ASSERT(!single_t::value || elemsafter >= 1);
 
-         pos = old_finish - difference_type(elemsafter);
-         if (elemsafter >= n) {
-            iterator finish_n = old_finish - difference_type(n);
+         if(single_t::value || elemsafter >= n) {
+            iterator finish_n = old_finish;
+            priv_itsub(finish_n, n, single_t());
             BOOST_CONTAINER_TRY {
-               ::boost::container::uninitialized_move_alloc(this->alloc(), finish_n, old_finish, old_finish);
+               this->priv_segmented_uninitialized_move_alloc_n(finish_n, n, old_finish, single_t());
             }
             BOOST_CONTAINER_CATCH(...) {
-               this->priv_destroy_nodes(this->members_.m_finish.m_node + 1, new_finish.m_node + 1);
+               this->prot_deallocate_nodes_if_not_reservable(old_finish.get_node() + 1, (old_finish + difference_type(n)).m_node + 1);
                BOOST_CONTAINER_RETHROW
             }
             BOOST_CONTAINER_CATCH_END
 
-            this->members_.m_finish = new_finish;
-            boost::container::move_backward(pos, finish_n, old_finish);
-            proxy.copy_n_and_update(this->alloc(), pos, n);
+            this->prot_inc_finish(n);
+            const size_type move_n = size_type(elemsafter - n);
+            this->priv_segmented_move_backward_n(finish_n, move_n, old_finish);
+            finish_n -= difference_type(move_n);
+            this->priv_segmented_proxy_copy_n_and_update(finish_n, n, proxy);
+            return finish_n;
          }
          else {
-            const size_type raw_gap = n - elemsafter;
+            const size_type raw_gap = size_type(n - elemsafter);
+            iterator pos            = old_finish - difference_type(elemsafter);
+
             BOOST_CONTAINER_TRY{
-               ::boost::container::uninitialized_move_alloc
-                  (this->alloc(), pos, old_finish, old_finish + difference_type(raw_gap));
+               this->priv_segmented_uninitialized_move_alloc_n(pos, elemsafter, old_finish + difference_type(raw_gap));
                BOOST_CONTAINER_TRY{
-                  proxy.copy_n_and_update(this->alloc(), pos, elemsafter);
-                  proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, raw_gap);
+                  this->priv_segmented_proxy_copy_n_and_update(pos, elemsafter, proxy);
+                  this->priv_segmented_proxy_uninitialized_copy_n_and_update(old_finish, raw_gap, proxy);
                }
                BOOST_CONTAINER_CATCH(...) {
-                  this->priv_destroy_range(old_finish, old_finish + difference_type(elemsafter));
+                  this->prot_destroy_range(old_finish, old_finish + difference_type(elemsafter));
                   BOOST_CONTAINER_RETHROW
                }
                BOOST_CONTAINER_CATCH_END
             }
             BOOST_CONTAINER_CATCH(...) {
-               this->priv_destroy_nodes(this->members_.m_finish.m_node + 1, new_finish.m_node + 1);
+               this->prot_deallocate_nodes_if_not_reservable(old_finish.get_node() + 1, (old_finish + difference_type(n)).m_node + 1);
                BOOST_CONTAINER_RETHROW
             }
             BOOST_CONTAINER_CATCH_END
-            this->members_.m_finish = new_finish;
+            this->prot_inc_finish(n);
+            return pos;
          }
       }
-      return this->begin() + difference_type(pos_n);
    }
 
    template<class InsertProxy>
    iterator priv_insert_aux_impl(const_iterator p, size_type n, InsertProxy proxy)
    {
-      iterator pos(p.unconst());
-      const size_type elemsbefore = static_cast<size_type>(pos - this->members_.m_start);
-      const size_type length = this->size();
+      const size_type elemsbefore = this->prot_it_to_start_off(p);
 
       if (!elemsbefore) {
          return this->priv_insert_front_aux_impl(n, proxy);
       }
-      else if (elemsbefore == length) {
+      else if (elemsbefore == this->prot_size()) {
          return this->priv_insert_back_aux_impl(n, proxy);
       }
       else {
-         return this->priv_insert_middle_aux_impl(p, elemsbefore, length, n, proxy);
+         return this->priv_insert_middle_aux_impl(elemsbefore, n, proxy);
       }
    }
 
    template <class InsertProxy>
-   iterator priv_insert_back_aux_impl(size_type n, InsertProxy proxy)
+   void priv_segmented_proxy_uninitialized_copy_n_and_update(const iterator first, size_type n, InsertProxy &proxy)
    {
-      if(!this->members_.m_map){
-         this->priv_initialize_map(0);
+      BOOST_IF_CONSTEXPR (dtl::is_single_value_proxy<InsertProxy>::value) {
+         (void)n;
+         proxy.uninitialized_copy_n_and_update(this->alloc(), boost::movelib::to_raw_pointer(first.get_cur()), 1u);
       }
+      else if (BOOST_LIKELY(n != 0)){ //We might initialize an empty range and current_node might be null
+         BOOST_CONSTEXPR_OR_CONST size_type block_size = get_block_size();
 
-      iterator new_finish = this->priv_reserve_elements_at_back(n);
-      BOOST_CONTAINER_TRY{
-         proxy.uninitialized_copy_n_and_update(this->alloc(), this->members_.m_finish, n);
-      }
-      BOOST_CONTAINER_CATCH(...) {
-         this->priv_destroy_nodes(this->members_.m_finish.m_node + 1, new_finish.m_node + 1);
-         BOOST_CONTAINER_RETHROW
+         index_pointer current_node = first.get_node();
+
+         BOOST_CONTAINER_TRY{
+            const pointer cur = first.get_cur();
+            const size_type block = size_type(block_size - size_type(cur - *current_node));
+            size_type cnt = n < block ? n: block;
+            proxy.uninitialized_copy_n_and_update(this->alloc(), boost::movelib::to_raw_pointer(cur), cnt);
+            n = size_type(n - cnt);
+
+            while (n) {
+               ++current_node;
+               cnt = n < block_size ? n: block_size;
+               proxy.uninitialized_copy_n_and_update(this->alloc(), boost::movelib::to_raw_pointer(*current_node), cnt);
+               n = size_type(n - cnt);
+            }
+         }
+         BOOST_CONTAINER_CATCH(...) {
+            this->prot_destroy_range(first, iterator(*current_node, current_node));
+            BOOST_CONTAINER_RETHROW
+         }
+         BOOST_CONTAINER_CATCH_END
       }
-      BOOST_CONTAINER_CATCH_END
-      this->members_.m_finish = new_finish;
-      return iterator(this->members_.m_finish - difference_type(n));
    }
 
+
    template <class InsertProxy>
-   iterator priv_insert_front_aux_impl(size_type n, InsertProxy proxy)
+   void priv_segmented_proxy_copy_n_and_update(const iterator first, size_type n, InsertProxy &proxy)
    {
-      if(!this->members_.m_map){
-         this->priv_initialize_map(0);
+      BOOST_IF_CONSTEXPR (dtl::is_single_value_proxy<InsertProxy>::value) {
+         (void)n;
+         proxy.copy_n_and_update(this->alloc(), boost::movelib::to_raw_pointer(first.get_cur()), 1u);
       }
+      else if (BOOST_LIKELY(n != 0)){ //We might assign an empty range in a default constructed deque
+         BOOST_CONSTEXPR_OR_CONST size_type block_size = get_block_size();
 
-      iterator new_start = this->priv_reserve_elements_at_front(n);
+         index_pointer current_node = first.get_node();
+
+         const pointer cur = first.get_cur();
+         const size_type block = size_type(block_size - size_type(cur - *current_node));
+         size_type cnt = n < block ? n: block;
+         proxy.copy_n_and_update(this->alloc(), boost::movelib::to_raw_pointer(cur), cnt);
+         n = size_type(n - cnt);
+
+         while (n) {
+            ++current_node;
+            cnt = n < block_size ? n: block_size;
+            proxy.copy_n_and_update(this->alloc(), boost::movelib::to_raw_pointer(*current_node), cnt);
+            n = size_type(n - cnt);
+         }
+      }
+   }
+
+   template <class InsertProxy>
+   void priv_insert_segmented_uninitialized_copy_n_and_update(const iterator first, size_type n, InsertProxy proxy)
+   {
       BOOST_CONTAINER_TRY{
-         proxy.uninitialized_copy_n_and_update(this->alloc(), new_start, n);
+         this->priv_segmented_proxy_uninitialized_copy_n_and_update(first, n, proxy);
       }
       BOOST_CONTAINER_CATCH(...) {
-         this->priv_destroy_nodes(new_start.m_node, this->members_.m_start.m_node);
+         this->prot_deallocate_nodes_if_not_reservable(first.get_node() + 1, (first+difference_type(n)).get_node() + 1);
          BOOST_CONTAINER_RETHROW
       }
       BOOST_CONTAINER_CATCH_END
+   }
 
-      this->members_.m_start = new_start;
-      return new_start;
+   template<class It>
+   static BOOST_CONTAINER_FORCEINLINE void priv_itadd(It &it, size_type, dtl::bool_<true> /*single element*/)
+   {  ++it; }
+
+   template<class It>
+   static BOOST_CONTAINER_FORCEINLINE void priv_itadd(It &it, size_type n, dtl::bool_<false> /*!single element*/)
+   {  it += difference_type(n); }
+
+   template<class It>
+   static BOOST_CONTAINER_FORCEINLINE void priv_itsub(It &it, size_type, dtl::bool_<true> /*single element*/)
+   {  --it; }
+
+   template<class It>
+   static BOOST_CONTAINER_FORCEINLINE void priv_itsub(It &it, size_type n, dtl::bool_<false> /*!single element*/)
+   {  it -= difference_type(n); }
+
+   void priv_segmented_uninitialized_move_alloc_n(iterator first, size_type n, iterator dest, dtl::bool_<true> /*single element*/)
+   {
+      BOOST_ASSERT(n == 1); (void)n;
+      allocator_traits_type::construct
+         ( this->alloc()
+         , boost::movelib::to_raw_pointer(dest.get_cur())
+         , boost::move(*first));
    }
 
-   inline iterator priv_fill_insert(const_iterator pos, size_type n, const value_type& x)
+   void priv_segmented_uninitialized_move_alloc_n(iterator first, size_type n, iterator dest, dtl::bool_<false> /*!single element*/)
    {
-      return this->insert(pos, c_it(x, n), c_it());
+      if (BOOST_LIKELY(n != 0)) { //Check for empty range, current_node might be null
+         BOOST_CONSTEXPR_OR_CONST size_type block_size = get_block_size();
+
+         index_pointer current_node = first.get_node();
+
+         BOOST_CONTAINER_TRY{
+            const pointer cur = first.get_cur();
+            const size_type block = size_type(block_size - size_type(cur - *current_node));
+            size_type cnt = n < block ? n: block;
+            dest = ::boost::container::uninitialized_move_alloc_n(this->alloc(), boost::movelib::to_raw_pointer(cur), cnt, dest);
+            n = size_type(n - cnt);
+
+            while (n) {
+               ++current_node;
+               cnt = n < block_size ? n: block_size;
+               dest = ::boost::container::uninitialized_move_alloc_n(this->alloc(), boost::movelib::to_raw_pointer(*current_node), cnt, dest);
+               n = size_type(n - cnt);
+            }
+         }
+         BOOST_CONTAINER_CATCH(...) {
+            this->prot_destroy_range(first, iterator(*current_node, current_node));
+            BOOST_CONTAINER_RETHROW
+         }
+         BOOST_CONTAINER_CATCH_END
+      }
    }
 
-   // Precondition: this->members_.m_start and this->members_.m_finish have already been initialized,
-   // but none of the deque's elements have yet been constructed.
-   void priv_fill_initialize(const value_type& value)
+   BOOST_CONTAINER_FORCEINLINE void priv_segmented_uninitialized_move_alloc_n(iterator first, size_type n, iterator dest)
    {
-      index_pointer cur = this->members_.m_start.m_node;
-      BOOST_CONTAINER_TRY {
-         for ( ; cur < this->members_.m_finish.m_node; ++cur){
-            boost::container::uninitialized_fill_alloc
-               (this->alloc(), *cur, *cur + get_block_ssize(), value);
+      this->priv_segmented_uninitialized_move_alloc_n(first, n, dest, dtl::bool_<false>());
+   }
+
+   void priv_segmented_uninitialized_copy_alloc_n(const_iterator first, size_type n, iterator dest)
+   {
+      if (BOOST_LIKELY(n != 0)) { //We might initialize an empty range and current_node might be null
+         BOOST_CONSTEXPR_OR_CONST size_type block_size = get_block_size();
+
+         index_pointer current_node = first.get_node();
+
+         BOOST_CONTAINER_TRY{
+            const pointer cur = first.get_cur();
+            const size_type block = size_type(block_size - size_type(cur - *current_node));
+            size_type cnt = n < block ? n: block;
+            dest = ::boost::container::uninitialized_copy_alloc_n(this->alloc(), boost::movelib::to_raw_pointer(cur), cnt, dest);
+            n = size_type(n - cnt);
+
+            while (n) {
+               ++current_node;
+               cnt = n < block_size ? n: block_size;
+               dest = ::boost::container::uninitialized_copy_alloc_n(this->alloc(), boost::movelib::to_raw_pointer(*current_node), cnt, dest);
+               n = size_type(n - cnt);
+            }
+         }
+         BOOST_CONTAINER_CATCH(...) {
+            this->prot_destroy_range(first.unconst(), iterator(*current_node, current_node));
+            BOOST_CONTAINER_RETHROW
          }
-         boost::container::uninitialized_fill_alloc
-            (this->alloc(), this->members_.m_finish.get_first(), this->members_.m_finish.m_cur, value);
+         BOOST_CONTAINER_CATCH_END
       }
-      BOOST_CONTAINER_CATCH(...){
-         this->priv_destroy_range(this->members_.m_start, iterator(*cur, cur, get_block_size()));
-         BOOST_CONTAINER_RETHROW
+   }
+
+   static iterator priv_segmented_move_n(const_iterator first, size_type n, iterator dest)
+   {
+      index_pointer current_node = first.get_node();
+      BOOST_ASSERT(current_node != index_pointer());
+
+      const pointer cur = first.get_cur();
+      BOOST_CONSTEXPR_OR_CONST size_type block_size = get_block_size();
+
+      const size_type block = size_type(block_size - size_type(cur - *current_node));
+      size_type cnt = n < block ? n: block;
+      dest = ::boost::container::move_n(boost::movelib::to_raw_pointer(cur), cnt, dest);
+      n = size_type(n - cnt);
+
+      while (n) {
+         ++current_node;
+         cnt = n < block_size ? n: block_size;
+         dest = ::boost::container::move_n(boost::movelib::to_raw_pointer(*current_node), cnt, dest);
+         n = size_type(n - cnt);
       }
-      BOOST_CONTAINER_CATCH_END
+      return dest;
+   }
+
+   static iterator priv_segmented_move_backward_n(iterator last, size_type n, iterator dest_last)
+   {
+      index_pointer current_node = last.get_node();
+      BOOST_ASSERT(current_node != index_pointer());
+
+      const pointer cur = last.get_cur();
+      const size_type block = size_type(cur - *current_node);
+      size_type cnt = n < block ? n: block;
+      dest_last = ::boost::container::move_backward_n(boost::movelib::to_raw_pointer(cur), cnt, dest_last);
+      n = size_type(n - cnt);
+
+      BOOST_CONSTEXPR_OR_CONST size_type block_size = get_block_size();
+
+      while (n) {
+         --current_node;
+         cnt = n < block_size ? n: block_size;
+         dest_last = ::boost::container::move_backward_n(boost::movelib::to_raw_pointer(*current_node + difference_type(block_size)), cnt, dest_last);
+         n = size_type(n - cnt);
+      }
+      return dest_last;
+   }
+
+   template <class InsertProxy>
+   iterator priv_insert_back_aux_impl(size_type n, InsertProxy proxy)
+   {
+      this->priv_reserve_elements_at_back(n);
+      const iterator old_finish = this->prot_finish();
+      this->priv_insert_segmented_uninitialized_copy_n_and_update(old_finish, n, proxy);
+      this->prot_inc_finish(n);
+      return old_finish;
+   }
+
+   template <class InsertProxy>
+   iterator priv_insert_front_aux_impl(size_type n, InsertProxy proxy)
+   {
+      this->priv_reserve_elements_at_front(n);
+      const iterator old_start = this->prot_start();
+      const iterator new_start = old_start - difference_type(n);
+      this->priv_insert_segmented_uninitialized_copy_n_and_update(new_start, n, proxy);
+      this->prot_dec_start(n);
+      return new_start;
+   }
+
+   // Precondition: this->prot_start() and this->prot_finish() have already been initialized,
+   // but none of the deque's elements have yet been constructed.
+   void priv_fill_initialize(size_type n, const value_type& value)
+   {
+      dtl::insert_n_copies_proxy<ValAllocator> proxy(value);
+      this->priv_segmented_proxy_uninitialized_copy_n_and_update(this->begin(), n, proxy);
    }
 
    template <class InIt>
    void priv_range_initialize(InIt first, InIt last, typename iterator_enable_if_tag<InIt, std::input_iterator_tag>::type* =0)
    {
-      this->priv_initialize_map(0);
       BOOST_CONTAINER_TRY {
          for ( ; first != last; ++first)
             this->emplace_back(*first);
@@ -2721,136 +2983,78 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    template <class FwdIt>
    void priv_range_initialize(FwdIt first, FwdIt last, typename iterator_disable_if_tag<FwdIt, std::input_iterator_tag>::type* =0)
    {
-      size_type n = 0;
-      n = boost::container::iterator_udistance(first, last);
-      this->priv_initialize_map(n);
-
-      index_pointer cur_node = this->members_.m_start.m_node;
-      BOOST_CONTAINER_TRY {
-         for (; cur_node < this->members_.m_finish.m_node; ++cur_node) {
-            FwdIt mid = first;
-            boost::container::iterator_uadvance(mid, get_block_size());
-            ::boost::container::uninitialized_copy_alloc(this->alloc(), first, mid, *cur_node);
-            first = mid;
-         }
-         ::boost::container::uninitialized_copy_alloc(this->alloc(), first, last, this->members_.m_finish.get_first());
-      }
-      BOOST_CONTAINER_CATCH(...){
-         this->priv_destroy_range(this->members_.m_start, iterator(*cur_node, cur_node, get_block_size()));
-         BOOST_CONTAINER_RETHROW
+      typedef typename iter_size<FwdIt>::type it_size_type;
+      const it_size_type sz = boost::container::iterator_udistance(first, last);
+      if (BOOST_UNLIKELY(sz > size_type(-1))){
+         boost::container::throw_length_error("vector::insert, FwdIt's max length reached");
       }
-      BOOST_CONTAINER_CATCH_END
+      const size_type n = static_cast<size_type>(sz);
+      this->prot_initialize_map_and_nodes(n);
+
+      dtl::insert_range_proxy<ValAllocator, FwdIt> proxy(first);
+      this->priv_segmented_proxy_uninitialized_copy_n_and_update(this->begin(), n, proxy);
    }
 
-   // Called only if this->members_.m_finish.m_cur == this->members_.m_finish.get_first().
+   // Called only if this->prot_finish_cur() == this->prot_finish().get_first().
    void priv_pop_back_aux() BOOST_NOEXCEPT_OR_NOTHROW
    {
-      this->priv_deallocate_node(this->members_.m_finish.get_first());
-      this->members_.m_finish.priv_set_node(this->members_.m_finish.m_node - 1, get_block_size());
-      this->members_.m_finish.m_cur = this->members_.m_finish.get_last() - 1;
+      index_pointer ip = this->prot_finish_node();
+      this->prot_deallocate_node_if_not_reservable(*ip);
+      this->prot_dec_finish();
+      --ip;
       allocator_traits_type::destroy
          ( this->alloc()
-         , boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur)
+         , boost::movelib::to_raw_pointer(this->prot_node_last(ip))
          );
    }
 
-   // Called only if this->members_.m_start.m_cur == this->members_.m_start.get_last() - 1.  Note that
+   // Called only if this->prot_start_cur() == this->prot_start().get_last() - 1.  Note that
    // if the deque has at least one element (a precondition for this member
-   // function), and if this->members_.m_start.m_cur == this->members_.m_start.get_last(), then the deque
+   // function), and if this->prot_start_cur() == this->prot_start().get_last(), then the deque
    // must have at least two nodes.
    void priv_pop_front_aux() BOOST_NOEXCEPT_OR_NOTHROW
    {
+      const index_pointer ip = this->prot_start_node();
       allocator_traits_type::destroy
          ( this->alloc()
-         , boost::movelib::to_raw_pointer(this->members_.m_start.m_cur)
+         , boost::movelib::to_raw_pointer(this->prot_node_last(ip))
          );
-      this->priv_deallocate_node(this->members_.m_start.get_first());
-      this->members_.m_start.priv_set_node(this->members_.m_start.m_node + 1, get_block_size());
-      this->members_.m_start.m_cur = this->members_.m_start.get_first();
+      this->prot_deallocate_node_if_not_reservable(*ip);
+      this->prot_inc_start();
    }
 
-   iterator priv_reserve_elements_at_front(size_type n)
+   void priv_reserve_elements_at_front(size_type n)
    {
-      size_type vacancies = size_type(this->members_.m_start.m_cur - this->members_.m_start.get_first());
-      if (n > vacancies){
-         size_type new_elems = n-vacancies;
-         size_type new_nodes = (new_elems + get_block_size() - 1u) / get_block_size();
-         size_type s = (size_type)(this->members_.m_start.m_node - this->members_.m_map);
-         if (new_nodes > s){
-            this->priv_reallocate_map(new_nodes, true);
-         }
-         size_type i = 1;
-         BOOST_CONTAINER_TRY {
-            for (; i <= new_nodes; ++i)
-               *(this->members_.m_start.m_node - difference_type(i)) = this->priv_allocate_node();
+      const size_type vacancies = this->prot_front_free_capacity();
+      typedef dtl::bool_<is_reservable> res_t;
+
+      if (n > vacancies){  //n == 0 handled in the else part
+         if(this->members_.m_map){
+            this->prot_reallocate_map_and_nodes(res_t(), size_type(n - vacancies), true);
          }
-         BOOST_CONTAINER_CATCH(...) {
-            for (size_type j = 1; j < i; ++j)
-               this->priv_deallocate_node(*(this->members_.m_start.m_node - difference_type(j)));
-            BOOST_CONTAINER_RETHROW
+         else {
+            this->prot_initialize_map_and_nodes(n);
+            this->prot_reset_start_to_finish();
          }
-         BOOST_CONTAINER_CATCH_END
       }
-      return this->members_.m_start - difference_type(n);
    }
 
-   iterator priv_reserve_elements_at_back(size_type n)
+   void priv_reserve_elements_at_back(size_type n)
    {
-      size_type vacancies = size_type(this->members_.m_finish.get_last() - this->members_.m_finish.m_cur - 1);
-      if (n > vacancies){
-         size_type new_elems = size_type(n - vacancies);
-         size_type new_nodes = size_type(new_elems + get_block_size() - 1u)/get_block_size();
-         size_type s = (size_type)(this->members_.m_map_size - size_type(this->members_.m_finish.m_node - this->members_.m_map));
-         if (new_nodes + 1 > s){
-            this->priv_reallocate_map(new_nodes, false);
-         }
-         size_type i = 1;
-         BOOST_CONTAINER_TRY {
-            for (; i <= new_nodes; ++i)
-               *(this->members_.m_finish.m_node + difference_type(i)) = this->priv_allocate_node();
+      const size_type vacancies = this->prot_back_free_capacity();
+      typedef dtl::bool_<is_reservable> res_t;
+
+      if (n > vacancies){  //n == 0 handled in the else part
+         if(this->members_.m_map){
+            this->prot_reallocate_map_and_nodes(res_t(), size_type(n - vacancies), false);
          }
-         BOOST_CONTAINER_CATCH(...) {
-            for (size_type j = 1; j < i; ++j)
-               this->priv_deallocate_node(*(this->members_.m_finish.m_node + difference_type(j)));
-            BOOST_CONTAINER_RETHROW
+         else{
+            this->prot_initialize_map_and_nodes(n);
+            this->prot_reset_finish_to_start();
          }
-         BOOST_CONTAINER_CATCH_END
       }
-      return this->members_.m_finish + difference_type(n);
    }
 
-   void priv_reallocate_map(size_type nodes_to_add, bool add_at_front)
-   {
-      size_type old_num_nodes = size_type(this->members_.m_finish.m_node - this->members_.m_start.m_node + 1);
-      size_type new_num_nodes = old_num_nodes + nodes_to_add;
-
-      index_pointer new_nstart;
-      if (this->members_.m_map_size > 2 * new_num_nodes) {
-         new_nstart = this->members_.m_map + difference_type(this->members_.m_map_size - new_num_nodes) / 2
-                           + difference_type(add_at_front ? nodes_to_add : 0u);
-         if (new_nstart < this->members_.m_start.m_node)
-            boost::container::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
-         else
-            boost::container::move_backward
-               (this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart + difference_type(old_num_nodes));
-      }
-      else {
-         size_type new_map_size =
-            this->members_.m_map_size + dtl::max_value(this->members_.m_map_size, nodes_to_add) + 2;
-
-         index_pointer new_map = this->priv_allocate_map(new_map_size);
-         new_nstart = new_map + difference_type(new_map_size - new_num_nodes) / 2
-                              + difference_type(add_at_front ? nodes_to_add : 0u);
-         boost::container::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
-         this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
-
-         this->members_.m_map = new_map;
-         this->members_.m_map_size = new_map_size;
-      }
-
-      this->members_.m_start.priv_set_node(new_nstart, get_block_size());
-      this->members_.m_finish.priv_set_node(new_nstart + difference_type(old_num_nodes - 1u), get_block_size());
-   }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
@@ -2861,6 +3065,28 @@ template <typename InputIterator, typename Allocator>
 deque(InputIterator, InputIterator, Allocator const&) -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
 #endif
 
+//! <b>Effects</b>: Erases all elements that compare equal to v from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class O, class U>
+inline typename deque<T, A, O>::size_type erase(deque<T, A, O>& c, const U& v)
+{
+   typename deque<T, A, O>::size_type old_size = c.size();
+   c.erase(boost::container::remove(c.begin(), c.end(), v), c.end());
+   return old_size - c.size();
+}
+
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class O, class Pred>
+inline typename deque<T, A, O>::size_type erase_if(deque<T, A, O>& c, Pred pred)
+{
+   typename deque<T, A, O>::size_type old_size = c.size();
+   c.erase(boost::container::remove_if(c.begin(), c.end(), pred), c.end());
+   return old_size - c.size();
+}
+
 }  //namespace container
 }  //namespace boost