passenger 6.0.14 → 6.0.27

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

@@ -50,7 +50,6 @@
 #include <boost/move/detail/move_helpers.hpp>
 // other
 #include <boost/assert.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 // std
 #include <cstddef>
 
@@ -69,16 +68,16 @@ template <class T>
 struct deque_value_traits
 {
    typedef T value_type;
-   static const bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;
-   static const bool trivial_dctr_after_move = ::boost::has_trivial_destructor_after_move<value_type>::value;
+   BOOST_STATIC_CONSTEXPR bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;
+   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
 {
-   BOOST_STATIC_ASSERT_MSG(!(BlockBytes && BlockSize), "BlockBytes and BlockSize can't be specified at the same time");
-   static const std::size_t block_bytes = BlockBytes ? BlockBytes : 512u;
-   static const std::size_t value       = BlockSize ? BlockSize : (sizeof(T) < block_bytes ? (block_bytes/sizeof(T)) : std::size_t(1));
+   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 {
@@ -107,6 +106,10 @@ namespace dtl {
 //    [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
 {
@@ -114,6 +117,7 @@ class deque_iterator
    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
@@ -142,43 +146,47 @@ class deque_iterator
 
    public:
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE Pointer get_cur()          const  {  return m_cur;  }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE Pointer get_first()        const  {  return m_first;  }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE Pointer get_last()         const  {  return m_last;  }
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE index_pointer get_node()   const  {  return m_node;  }
+   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;  }
 
-   BOOST_CONTAINER_FORCEINLINE deque_iterator(val_alloc_ptr x, index_pointer y, difference_type block_size) BOOST_NOEXCEPT_OR_NOTHROW
+   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)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW
+   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)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE deque_iterator(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
+   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())
    {}
 
-   BOOST_CONTAINER_FORCEINLINE deque_iterator(const nonconst_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
+   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())
    {}
 
-   BOOST_CONTAINER_FORCEINLINE deque_iterator(Pointer cur, Pointer first, Pointer last, index_pointer node) BOOST_NOEXCEPT_OR_NOTHROW
+   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)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE deque_iterator& operator=(const deque_iterator& x) BOOST_NOEXCEPT_OR_NOTHROW
+   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; }
 
-   BOOST_CONTAINER_FORCEINLINE deque_iterator<Pointer, false> unconst() const BOOST_NOEXCEPT_OR_NOTHROW
+   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());
    }
 
-   BOOST_CONTAINER_FORCEINLINE reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW
       { return *this->m_cur; }
 
-   BOOST_CONTAINER_FORCEINLINE pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW
+   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
@@ -186,7 +194,7 @@ class deque_iterator
       if(!this->m_cur && !x.m_cur){
          return 0;
       }
-      const difference_type block_size = this->m_last - this->m_first;
+      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);
@@ -205,7 +213,7 @@ class deque_iterator
       return *this;
    }
 
-   BOOST_CONTAINER_FORCEINLINE deque_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
+   inline deque_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
    {
       deque_iterator tmp(*this);
       ++*this;
@@ -225,7 +233,7 @@ class deque_iterator
       return *this;
    }
 
-   BOOST_CONTAINER_FORCEINLINE deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
+   inline deque_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
    {
       deque_iterator tmp(*this);
       --*this;
@@ -237,67 +245,71 @@ class deque_iterator
       if (!n)
          return *this;
       BOOST_ASSERT(!!m_cur);
-      difference_type offset = n + (this->m_cur - this->m_first);
-      const difference_type block_size = this->m_last - this->m_first;
+      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 += n;
+         this->m_cur += difference_type(n);
       else {
-         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, block_size);
+         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 BOOST_CONTAINER_FORCEINLINE
+   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_FORCEINLINE
+   inline
       deque_iterator& operator-=(difference_type n) BOOST_NOEXCEPT_OR_NOTHROW
       { return *this += -n; }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   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 BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
       { return *(*this + n); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   //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 BOOST_CONTAINER_FORCEINLINE
+   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 BOOST_CONTAINER_FORCEINLINE
+   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 BOOST_CONTAINER_FORCEINLINE
+   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 BOOST_CONTAINER_FORCEINLINE
+   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 BOOST_CONTAINER_FORCEINLINE
+   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 BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW
       {  return x += n;  }
 
-   BOOST_CONTAINER_FORCEINLINE void priv_set_node(index_pointer new_node, difference_type block_size) BOOST_NOEXCEPT_OR_NOTHROW
+   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;
@@ -305,6 +317,447 @@ class deque_iterator
    }
 };
 
+#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 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
+   {
+      BOOST_CONTAINER_STATIC_ASSERT((deque_block_size<value_type, BlockBytes, BlockSize>::value));
+      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;
+   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;  }
+
+   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
+      : m_cur(x), m_node(y)
+   {}
+
+   inline deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW
+      : m_cur(), 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_node(x.get_node())
+   {}
+
+   inline deque_iterator(const nonconst_iterator& 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 nonconst_iterator unconst() const BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      return nonconst_iterator(this->get_cur(), 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->get_first()) + (x.get_last() - x.m_cur);
+   }
+
+   deque_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(!!m_cur);
+      ++this->m_cur;
+      if (this->m_cur == (this->get_last())) {
+
+         ++this->m_node;
+         this->m_cur = *this->m_node;
+      }
+      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->get_first()) {
+         --this->m_node;
+         this->m_cur = this->get_last();
+      }
+      --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->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);
+      }
+      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
+   {
+      BOOST_ASSERT(!!m_cur);
+      const difference_type offset = n + (this->m_cur - this->get_first());
+      const difference_type block_size = get_block_ssize();
+      if (offset >= 0 && offset < block_size)
+         return this->m_cur[difference_type(n)];
+      else {
+         const difference_type node_offset = offset > 0
+            ? (offset / block_size)
+            : (-difference_type((-offset - 1) / block_size) - 1);
+         return (this->m_node[node_offset]) [offset - node_offset * block_size];
+      }
+   }
+
+   //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;
+   }
+};
+
+#else
+
+#error "Invalid BOOST_CONTAINER_DEQUE_LIGHTER_ITERATOR_LEVEL"
+
+#endif
 }  //namespace dtl {
 
 template<class Options>
@@ -346,45 +799,54 @@ class deque_base
    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;
 
    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;
+   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
+
+   BOOST_CONSTEXPR inline static val_alloc_diff get_block_ssize() BOOST_NOEXCEPT_OR_NOTHROW
+      { return val_alloc_diff((get_block_size())); }
 
-   BOOST_CONSTEXPR BOOST_CONTAINER_FORCEINLINE static size_type get_block_size() BOOST_NOEXCEPT_OR_NOTHROW
+   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; }
 
    typedef deque_value_traits<val_alloc_val>             traits_t;
    typedef ptr_alloc_t                                   map_allocator_type;
 
-   BOOST_CONTAINER_FORCEINLINE val_alloc_ptr priv_allocate_node()
+   inline val_alloc_ptr priv_allocate_node()
       {  return this->alloc().allocate(get_block_size());  }
 
-   BOOST_CONTAINER_FORCEINLINE void priv_deallocate_node(val_alloc_ptr p) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void priv_deallocate_node(val_alloc_ptr p) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->alloc().deallocate(p, get_block_size());  }
 
-   BOOST_CONTAINER_FORCEINLINE ptr_alloc_ptr priv_allocate_map(size_type n)
+   inline ptr_alloc_ptr priv_allocate_map(size_type n)
       { return this->ptr_alloc().allocate(n); }
 
-   BOOST_CONTAINER_FORCEINLINE void priv_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void priv_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_NOEXCEPT_OR_NOTHROW
       { this->ptr_alloc().deallocate(p, n); }
 
-   BOOST_CONTAINER_FORCEINLINE deque_base(size_type num_elements, const allocator_type& a)
+   inline deque_base(size_type num_elements, const allocator_type& a)
       :  members_(a)
    { this->priv_initialize_map(num_elements); }
 
-   BOOST_CONTAINER_FORCEINLINE explicit deque_base(const allocator_type& a)
+   inline explicit deque_base(const allocator_type& a)
       :  members_(a)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE deque_base()
+   inline deque_base()
       :  members_()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit deque_base(BOOST_RV_REF(deque_base) x)
+   inline explicit deque_base(BOOST_RV_REF(deque_base) x)
       :  members_( boost::move(x.ptr_alloc())
                  , boost::move(x.alloc()) )
    {}
@@ -418,40 +880,39 @@ class deque_base
          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 nstart = this->members_.m_map + (this->members_.m_map_size - num_nodes) / 2;
-         ptr_alloc_ptr nfinish = nstart + num_nodes;
+         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);
 
-         BOOST_TRY {
+         BOOST_CONTAINER_TRY {
             this->priv_create_nodes(nstart, nfinish);
          }
-         BOOST_CATCH(...){
+         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;
-            BOOST_RETHROW
+            BOOST_CONTAINER_RETHROW
          }
-         BOOST_CATCH_END
+         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.m_first;
-         this->members_.m_finish.m_cur = this->members_.m_finish.m_first +
-                        num_elements % 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());
 //      }
    }
 
    void priv_create_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish)
    {
       ptr_alloc_ptr cur = nstart;
-      BOOST_TRY {
+      BOOST_CONTAINER_TRY {
          for (; cur < nfinish; ++cur)
             *cur = this->priv_allocate_node();
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->priv_destroy_nodes(nstart, cur);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    void priv_destroy_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_NOEXCEPT_OR_NOTHROW
@@ -505,16 +966,16 @@ class deque_base
       iterator        m_finish;
    } members_;
 
-   BOOST_CONTAINER_FORCEINLINE ptr_alloc_t &ptr_alloc() BOOST_NOEXCEPT_OR_NOTHROW
+   inline ptr_alloc_t &ptr_alloc() BOOST_NOEXCEPT_OR_NOTHROW
    {  return members_;  }
 
-   BOOST_CONTAINER_FORCEINLINE const ptr_alloc_t &ptr_alloc() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline const ptr_alloc_t &ptr_alloc() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return members_;  }
 
-   BOOST_CONTAINER_FORCEINLINE allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW
+   inline allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW
    {  return members_;  }
 
-   BOOST_CONTAINER_FORCEINLINE const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return members_;  }
 };
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -538,6 +999,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    typedef deque_base<typename real_allocator<T, Allocator>::type, Options> Base;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    typedef typename real_allocator<T, Allocator>::type ValAllocator;
+   typedef constant_iterator<T> c_it;
 
    public:
 
@@ -564,16 +1026,23 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    private:                      // Internal typedefs
+
+   //`allocator_type::value_type` must match container's `value type`. If this
+   //assertion fails, please review your allocator definition. 
+   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;
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
+   using Base::get_block_ssize;
+
    public:
 
-   BOOST_CONSTEXPR BOOST_CONTAINER_FORCEINLINE static size_type get_block_size() BOOST_NOEXCEPT_OR_NOTHROW
-      { return Base::get_block_size(); }
+   using Base::get_block_size;
+
 
    //////////////////////////////////////////////
    //
@@ -586,7 +1055,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: If allocator_type's default constructor throws.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE deque()
+   inline deque()
       BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<ValAllocator>::value)
       : Base()
    {}
@@ -596,7 +1065,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE explicit deque(const allocator_type& a) BOOST_NOEXCEPT_OR_NOTHROW
+   inline explicit deque(const allocator_type& a) BOOST_NOEXCEPT_OR_NOTHROW
       : Base(a)
    {}
 
@@ -607,10 +1076,10 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //!   throws or T's value initialization throws.
    //!
    //! <b>Complexity</b>: Linear to n.
-   BOOST_CONTAINER_FORCEINLINE explicit deque(size_type n)
+   inline explicit deque(size_type n)
       : Base(n, allocator_type())
    {
-      dtl::insert_value_initialized_n_proxy<ValAllocator, iterator> proxy;
+      dtl::insert_value_initialized_n_proxy<ValAllocator> proxy;
       proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
       //deque_base will deallocate in case of exception...
    }
@@ -624,10 +1093,10 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to n.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_FORCEINLINE deque(size_type n, default_init_t)
+   inline deque(size_type n, default_init_t)
       : Base(n, allocator_type())
    {
-      dtl::insert_default_initialized_n_proxy<ValAllocator, iterator> proxy;
+      dtl::insert_default_initialized_n_proxy<ValAllocator> proxy;
       proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
       //deque_base will deallocate in case of exception...
    }
@@ -639,10 +1108,10 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //!   throws or T's value initialization throws.
    //!
    //! <b>Complexity</b>: Linear to n.
-   BOOST_CONTAINER_FORCEINLINE explicit deque(size_type n, const allocator_type &a)
+   inline explicit deque(size_type n, const allocator_type &a)
       : Base(n, a)
    {
-      dtl::insert_value_initialized_n_proxy<ValAllocator, iterator> proxy;
+      dtl::insert_value_initialized_n_proxy<ValAllocator> proxy;
       proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
       //deque_base will deallocate in case of exception...
    }
@@ -656,10 +1125,10 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to n.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_FORCEINLINE deque(size_type n, default_init_t, const allocator_type &a)
+   inline deque(size_type n, default_init_t, const allocator_type &a)
       : Base(n, a)
    {
-      dtl::insert_default_initialized_n_proxy<ValAllocator, iterator> proxy;
+      dtl::insert_default_initialized_n_proxy<ValAllocator> proxy;
       proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
       //deque_base will deallocate in case of exception...
    }
@@ -671,7 +1140,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //!   throws or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to n.
-   BOOST_CONTAINER_FORCEINLINE deque(size_type n, const value_type& value)
+   inline deque(size_type n, const value_type& value)
       : Base(n, allocator_type())
    { this->priv_fill_initialize(value); }
 
@@ -682,7 +1151,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //!   throws or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to n.
-   BOOST_CONTAINER_FORCEINLINE deque(size_type n, const value_type& value, const allocator_type& a)
+   inline deque(size_type n, const value_type& value, const allocator_type& a)
       : Base(n, a)
    { this->priv_fill_initialize(value); }
 
@@ -694,7 +1163,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //!
    //! <b>Complexity</b>: Linear to the range [first, last).
    template <class InIt>
-   BOOST_CONTAINER_FORCEINLINE deque(InIt first, InIt last
+   inline deque(InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       , typename dtl::disable_if_convertible
          <InIt, size_type>::type * = 0
@@ -713,7 +1182,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //!
    //! <b>Complexity</b>: Linear to the range [first, last).
    template <class InIt>
-   BOOST_CONTAINER_FORCEINLINE deque(InIt first, InIt last, const allocator_type& a
+   inline deque(InIt first, InIt last, const allocator_type& a
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       , typename dtl::disable_if_convertible
          <InIt, size_type>::type * = 0
@@ -732,7 +1201,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //!   throws or T's constructor taking a dereferenced std::initializer_list iterator throws.
    //!
    //! <b>Complexity</b>: Linear to the range [il.begin(), il.end()).
-   BOOST_CONTAINER_FORCEINLINE deque(std::initializer_list<value_type> il, const allocator_type& a = allocator_type())
+   inline deque(std::initializer_list<value_type> il, const allocator_type& a = allocator_type())
       : Base(a)
    {
       this->priv_range_initialize(il.begin(), il.end());
@@ -744,7 +1213,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Postcondition</b>: x == *this.
    //!
    //! <b>Complexity</b>: Linear to the elements x contains.
-   BOOST_CONTAINER_FORCEINLINE deque(const deque& x)
+   inline deque(const deque& x)
       :  Base(allocator_traits_type::select_on_container_copy_construction(x.alloc()))
    {
       if(x.size()){
@@ -759,7 +1228,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE deque(BOOST_RV_REF(deque) x) BOOST_NOEXCEPT_OR_NOTHROW
+   inline deque(BOOST_RV_REF(deque) x) BOOST_NOEXCEPT_OR_NOTHROW
       :  Base(BOOST_MOVE_BASE(Base, x))
    {  this->swap_members(x);   }
 
@@ -810,7 +1279,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements.
-   BOOST_CONTAINER_FORCEINLINE ~deque() BOOST_NOEXCEPT_OR_NOTHROW
+   inline ~deque() BOOST_NOEXCEPT_OR_NOTHROW
    {
       this->priv_destroy_range(this->members_.m_start, this->members_.m_finish);
    }
@@ -854,28 +1323,13 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
                                   || allocator_traits_type::is_always_equal::value)
    {
       if (BOOST_LIKELY(this != &x)) {
-         allocator_type &this_alloc = this->alloc();
-         allocator_type &x_alloc    = x.alloc();
-         const bool propagate_alloc = allocator_traits_type::
-               propagate_on_container_move_assignment::value;
-         dtl::bool_<propagate_alloc> flag;
-         const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal;
-         //Resources can be transferred if both allocators are
-         //going to be equal after this function (either propagated or already equal)
-         if(propagate_alloc || allocators_equal){
-            //Destroy objects but retain memory in case x reuses it in the future
-            this->clear();
-            //Move allocator if needed
-            dtl::move_alloc(this_alloc, x_alloc, flag);
-            dtl::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
-            //Nothrow swap
-            this->swap_members(x);
-         }
-         //Else do a one by one move
-         else{
-            this->assign( boost::make_move_iterator(x.begin())
-                        , boost::make_move_iterator(x.end()));
-         }
+         //We know resources can be transferred at comiple time if both allocators are
+         //always equal or the allocator is going to be propagated
+         const bool can_steal_resources_alloc
+            =  allocator_traits_type::propagate_on_container_move_assignment::value
+            || allocator_traits_type::is_always_equal::value;
+         dtl::bool_<can_steal_resources_alloc> flag;
+         this->priv_move_assign(boost::move(x), flag);
       }
       return *this;
    }
@@ -889,7 +1343,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to the number of elements in il.
-   BOOST_CONTAINER_FORCEINLINE deque& operator=(std::initializer_list<value_type> il)
+   inline deque& operator=(std::initializer_list<value_type> il)
    {
       this->assign(il.begin(), il.end());
       return *this;
@@ -901,9 +1355,8 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to n.
-   BOOST_CONTAINER_FORCEINLINE void assign(size_type n, const T& val)
+   inline void assign(size_type n, const T& val)
    {
-      typedef constant_iterator<value_type, difference_type> c_it;
       this->assign(c_it(val, n), c_it());
    }
 
@@ -946,10 +1399,10 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          >::type * = 0
       )
    {
-      const size_type len = boost::container::iterator_distance(first, last);
+      const size_type len = boost::container::iterator_udistance(first, last);
       if (len > size()) {
          FwdIt mid = first;
-         boost::container::iterator_advance(mid, this->size());
+         boost::container::iterator_uadvance(mid, this->size());
          boost::container::copy(first, mid, begin());
          this->insert(this->cend(), mid, last);
       }
@@ -966,7 +1419,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //!   T's constructor from dereferencing std::initializer_list iterator throws.
    //!
    //! <b>Complexity</b>: Linear to il.size().
-   BOOST_CONTAINER_FORCEINLINE void assign(std::initializer_list<value_type> il)
+   inline void assign(std::initializer_list<value_type> il)
    {   this->assign(il.begin(), il.end());   }
 #endif
 
@@ -975,7 +1428,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: If allocator's copy constructor throws.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
    { return Base::alloc(); }
 
@@ -986,7 +1439,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return Base::alloc(); }
 
@@ -1003,7 +1456,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
    {  return Base::alloc(); }
 
@@ -1012,7 +1465,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
       { return this->members_.m_start; }
 
@@ -1021,7 +1474,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return this->members_.m_start; }
 
@@ -1030,7 +1483,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator end() BOOST_NOEXCEPT_OR_NOTHROW
       { return this->members_.m_finish; }
 
@@ -1039,7 +1492,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
       { return this->members_.m_finish; }
 
@@ -1049,7 +1502,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
       { return reverse_iterator(this->members_.m_finish); }
 
@@ -1059,7 +1512,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return const_reverse_iterator(this->members_.m_finish); }
 
@@ -1069,7 +1522,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
       { return reverse_iterator(this->members_.m_start); }
 
@@ -1079,7 +1532,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return const_reverse_iterator(this->members_.m_start); }
 
@@ -1088,7 +1541,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return this->members_.m_start; }
 
@@ -1097,7 +1550,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return this->members_.m_finish; }
 
@@ -1107,7 +1560,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return const_reverse_iterator(this->members_.m_finish); }
 
@@ -1117,7 +1570,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return const_reverse_iterator(this->members_.m_start); }
 
@@ -1132,7 +1585,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
    { return this->members_.m_finish == this->members_.m_start; }
 
@@ -1141,16 +1594,16 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return this->members_.m_finish - this->members_.m_start; }
+      { return size_type(this->members_.m_finish - this->members_.m_start); }
 
    //! <b>Effects</b>: Returns the largest possible size of the deque.
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return allocator_traits_type::max_size(this->alloc()); }
 
@@ -1167,7 +1620,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          this->priv_erase_last_n(len - new_size);
       else{
          const size_type n = new_size - this->size();
-         dtl::insert_value_initialized_n_proxy<ValAllocator, iterator> proxy;
+         dtl::insert_value_initialized_n_proxy<ValAllocator> proxy;
          priv_insert_back_aux_impl(n, proxy);
       }
    }
@@ -1187,7 +1640,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          this->priv_erase_last_n(len - new_size);
       else{
          const size_type n = new_size - this->size();
-         dtl::insert_default_initialized_n_proxy<ValAllocator, iterator> proxy;
+         dtl::insert_default_initialized_n_proxy<ValAllocator> proxy;
          priv_insert_back_aux_impl(n, proxy);
       }
    }
@@ -1202,7 +1655,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    {
       const size_type len = size();
       if (new_size < len)
-         this->erase(this->members_.m_start + new_size, this->members_.m_finish);
+         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);
    }
@@ -1238,7 +1691,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reference front() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
@@ -1253,7 +1706,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reference front() const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
@@ -1268,7 +1721,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reference back() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
@@ -1283,7 +1736,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reference back() const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
@@ -1298,7 +1751,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() > n);
@@ -1313,7 +1766,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reference operator[](size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() > n);
@@ -1331,11 +1784,11 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() >= n);
-      return iterator(this->begin()+n);
+      return iterator(this->begin()+difference_type(n));
    }
 
    //! <b>Requires</b>: size() >= n.
@@ -1349,11 +1802,11 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() >= n);
-      return const_iterator(this->cbegin()+n);
+      return const_iterator(this->cbegin()+difference_type(n));
    }
 
    //! <b>Requires</b>: begin() <= p <= end().
@@ -1366,7 +1819,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       //Range checked priv_index_of
@@ -1383,7 +1836,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       //Range checked priv_index_of
@@ -1398,7 +1851,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: range_error if n >= size()
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reference at(size_type n)
    {
       this->priv_throw_if_out_of_range(n);
@@ -1413,7 +1866,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: range_error if n >= size()
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reference at(size_type n) const
    {
       this->priv_throw_if_out_of_range(n);
@@ -1449,7 +1902,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          return r;
       }
       else{
-         typedef dtl::insert_nonmovable_emplace_proxy<ValAllocator, iterator, Args...> type;
+         typedef dtl::insert_nonmovable_emplace_proxy<ValAllocator, Args...> type;
          return *this->priv_insert_front_aux_impl(1, type(boost::forward<Args>(args)...));
       }
    }
@@ -1475,7 +1928,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          return r;
       }
       else{
-         typedef dtl::insert_nonmovable_emplace_proxy<ValAllocator, iterator, Args...> type;
+         typedef dtl::insert_nonmovable_emplace_proxy<ValAllocator, Args...> type;
          return *this->priv_insert_back_aux_impl(1, type(boost::forward<Args>(args)...));
       }
    }
@@ -1502,7 +1955,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          return (this->end()-1);
       }
       else{
-         typedef dtl::insert_emplace_proxy<ValAllocator, iterator, Args...> type;
+         typedef dtl::insert_emplace_proxy<ValAllocator, Args...> type;
          return this->priv_insert_aux_impl(p, 1, type(boost::forward<Args>(args)...));
       }
    }
@@ -1522,7 +1975,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       }\
       else{\
          typedef dtl::insert_nonmovable_emplace_proxy##N\
-               <ValAllocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
+               <ValAllocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
          return *priv_insert_front_aux_impl(1, type(BOOST_MOVE_FWD##N));\
       }\
    }\
@@ -1539,7 +1992,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       }\
       else{\
          typedef dtl::insert_nonmovable_emplace_proxy##N\
-               <ValAllocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
+               <ValAllocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
          return *priv_insert_back_aux_impl(1, type(BOOST_MOVE_FWD##N));\
       }\
    }\
@@ -1558,7 +2011,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       }\
       else{\
          typedef dtl::insert_emplace_proxy_arg##N\
-               <ValAllocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
+               <ValAllocator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
          return this->priv_insert_aux_impl(p, 1, type(BOOST_MOVE_FWD##N));\
       }\
    }
@@ -1646,10 +2099,9 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: If memory allocation throws or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to n.
-   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator pos, size_type n, const value_type& x)
+   inline iterator insert(const_iterator pos, size_type n, const value_type& x)
    {
       //Range check of p is done by insert()
-      typedef constant_iterator<value_type, difference_type> c_it;
       return this->insert(pos, c_it(x, n), c_it());
    }
 
@@ -1681,7 +2133,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          it = this->emplace(it, *first);
          ++it;
       }
-      it -= n;
+      it -= difference_type(n);
       return it;
    }
 
@@ -1696,7 +2148,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //!   dereferenced std::initializer_list throws or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to distance [il.begin(), il.end()).
-   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator pos, std::initializer_list<value_type> il)
+   inline iterator insert(const_iterator pos, std::initializer_list<value_type> il)
    {
       //Range check os pos is done in insert()
       return insert(pos, il.begin(), il.end());
@@ -1705,7 +2157,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class FwdIt>
-   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, FwdIt first, FwdIt last
+   inline iterator insert(const_iterator p, FwdIt first, FwdIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       , typename dtl::disable_if_or
          < void
@@ -1716,8 +2168,8 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       )
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      dtl::insert_range_proxy<ValAllocator, FwdIt, iterator> proxy(first);
-      return priv_insert_aux_impl(p, boost::container::iterator_distance(first, last), proxy);
+      dtl::insert_range_proxy<ValAllocator, FwdIt> proxy(first);
+      return priv_insert_aux_impl(p, boost::container::iterator_udistance(first, last), proxy);
    }
    #endif
 
@@ -1729,7 +2181,7 @@ 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.m_last - 1) {
+      if (this->members_.m_start.m_cur != this->members_.m_start.get_last() - 1) {
          allocator_traits_type::destroy
             ( this->alloc()
             , boost::movelib::to_raw_pointer(this->members_.m_start.m_cur)
@@ -1748,7 +2200,7 @@ 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.m_first) {
+      if (this->members_.m_finish.m_cur != this->members_.m_finish.get_first()) {
          --this->members_.m_finish.m_cur;
          allocator_traits_type::destroy
             ( this->alloc()
@@ -1772,7 +2224,7 @@ 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 = pos - this->members_.m_start;
+      size_type index = size_type(pos - this->members_.m_start);
       if (index < (this->size()/2)) {
          boost::container::move_backward(this->begin(), pos.unconst(), next);
          pop_front();
@@ -1781,7 +2233,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          boost::container::move(next, this->end(), pos.unconst());
          pop_back();
       }
-      return this->members_.m_start + index;
+      return this->members_.m_start + difference_type(index);
    }
 
    //! <b>Effects</b>: Erases the elements pointed by [first, last).
@@ -1805,19 +2257,19 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          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 + n;
+            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;
          }
          else {
             boost::container::move(last.unconst(), end(), first.unconst());
-            iterator new_finish = this->members_.m_finish - n;
+            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;
          }
-         return this->members_.m_start + elems_before;
+         return this->members_.m_start + difference_type(elems_before);
       }
    }
 
@@ -1826,7 +2278,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE void swap(deque &x)
+   inline void swap(deque &x)
       BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_swap::value
                                || allocator_traits_type::is_always_equal::value)
    {
@@ -1848,14 +2300,14 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          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_size());
+            this->priv_destroy_range(*node, *node + get_block_ssize());
             this->priv_deallocate_node(*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.m_last);
-            this->priv_destroy_range(this->members_.m_finish.m_first, this->members_.m_finish.m_cur);
-            this->priv_deallocate_node(this->members_.m_finish.m_first);
+            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());
          }
          else
             this->priv_destroy_range(this->members_.m_start.m_cur, this->members_.m_finish.m_cur);
@@ -1867,56 +2319,80 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator==(const deque& x, const deque& y)
    {  return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());  }
 
    //! <b>Effects</b>: Returns true if x and y are unequal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator!=(const deque& x, const deque& y)
    {  return !(x == y); }
 
    //! <b>Effects</b>: Returns true if x is less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator<(const deque& x, const deque& y)
    {  return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
 
    //! <b>Effects</b>: Returns true if x is greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator>(const deque& x, const deque& y)
    {  return y < x;  }
 
    //! <b>Effects</b>: Returns true if x is equal or less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator<=(const deque& x, const deque& y)
    {  return !(y < x);  }
 
    //! <b>Effects</b>: Returns true if x is equal or greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator>=(const deque& x, const deque& y)
    {  return !(x < y);  }
 
    //! <b>Effects</b>: x.swap(y)
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE friend void swap(deque& x, deque& y)
+   inline friend void swap(deque& x, deque& y)
        BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT(x.swap(y)))
    {  x.swap(y);  }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
 
-   BOOST_CONTAINER_FORCEINLINE size_type priv_index_of(const_iterator p) const
+   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
+      this->clear();
+      //Move allocator if needed
+      dtl::bool_<allocator_traits_type::propagate_on_container_move_assignment::value> flag;
+      dtl::move_alloc(this->alloc(), x.alloc(), flag);
+      dtl::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
+      //Nothrow swap
+      this->swap_members(x);
+   }
+
+   void priv_move_assign(BOOST_RV_REF(deque) x, dtl::bool_<false> /*steal_resources*/)
+   {
+      //We can't guarantee a compile-time equal allocator or propagation so fallback to runtime
+      //Resources can be transferred if both allocators are equal
+      if (this->alloc() == x.alloc()) {
+         this->priv_move_assign(boost::move(x), dtl::true_());
+      }
+      else {
+         this->assign(boost::make_move_iterator(x.begin()), boost::make_move_iterator(x.end()));
+      }
+   }
+
+   inline size_type priv_index_of(const_iterator p) const
    {
       BOOST_ASSERT(this->cbegin() <= p);
       BOOST_ASSERT(p <= this->cend());
@@ -1929,7 +2405,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          this->clear();
       }
       else {
-         iterator new_finish = this->members_.m_finish - n;
+         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;
@@ -1942,12 +2418,12 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          throw_out_of_range("deque::at out of range");
    }
 
-   BOOST_CONTAINER_FORCEINLINE bool priv_in_range(const_iterator pos) const
+   inline bool priv_in_range(const_iterator pos) const
    {
       return (this->begin() <= pos) && (pos < this->end());
    }
 
-   BOOST_CONTAINER_FORCEINLINE bool priv_in_range_or_end(const_iterator pos) const
+   inline bool priv_in_range_or_end(const_iterator pos) const
    {
       return (this->begin() <= pos) && (pos <= this->end());
    }
@@ -2001,37 +2477,38 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       }
    }
 
-   BOOST_CONTAINER_FORCEINLINE bool priv_push_back_simple_available() const
+   inline bool priv_push_back_simple_available() const
    {
       return this->members_.m_map &&
-         (this->members_.m_finish.m_cur != (this->members_.m_finish.m_last - 1));
+         (this->members_.m_finish.m_cur != (this->members_.m_finish.get_last() - 1));
    }
 
-   BOOST_CONTAINER_FORCEINLINE T *priv_push_back_simple_pos() const
+   inline T *priv_push_back_simple_pos() const
    {
       return boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void priv_push_back_simple_commit()
+   inline void priv_push_back_simple_commit()
    {
       ++this->members_.m_finish.m_cur;
    }
 
-   BOOST_CONTAINER_FORCEINLINE bool priv_push_front_simple_available() const
+   inline bool priv_push_front_simple_available() const
    {
       return this->members_.m_map &&
-         (this->members_.m_start.m_cur != this->members_.m_start.m_first);
+         (this->members_.m_start.m_cur != this->members_.m_start.get_first());
    }
 
-   BOOST_CONTAINER_FORCEINLINE T *priv_push_front_simple_pos() const
+   inline T *priv_push_front_simple_pos() const
    {  return boost::movelib::to_raw_pointer(this->members_.m_start.m_cur) - 1;  }
 
-   BOOST_CONTAINER_FORCEINLINE void priv_push_front_simple_commit()
+   inline void priv_push_front_simple_commit()
    {  --this->members_.m_start.m_cur;   }
 
    void priv_destroy_range(iterator p, iterator p2)
    {
-      if(!Base::traits_t::trivial_dctr){
+      (void)p; (void)p2;
+      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));
          }
@@ -2040,7 +2517,8 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
 
    void priv_destroy_range(pointer p, pointer p2)
    {
-      if(!Base::traits_t::trivial_dctr){
+      (void)p; (void)p2;
+      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));
          }
@@ -2048,82 +2526,115 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    }
 
    template<class InsertProxy>
-   iterator priv_insert_aux_impl(const_iterator p, size_type n, InsertProxy proxy)
+   iterator priv_insert_middle_aux_impl(const_iterator p, const size_type elemsbefore, const size_type length, const size_type n, InsertProxy proxy)
    {
-      iterator pos(p.unconst());
-      const size_type pos_n = p - this->cbegin();
-      if(!this->members_.m_map){
+      if (!this->members_.m_map) {
          this->priv_initialize_map(0);
-         pos = this->begin();
+         p = this->cbegin();
       }
 
-      const size_type elemsbefore = static_cast<size_type>(pos - this->members_.m_start);
-      const size_type length = this->size();
+      iterator pos(p.unconst());
+      const size_type pos_n = size_type(p - this->cbegin());
+
       if (elemsbefore < length / 2) {
          const iterator new_start = this->priv_reserve_elements_at_front(n);
          const iterator old_start = this->members_.m_start;
-         if(!elemsbefore){
-            proxy.uninitialized_copy_n_and_update(this->alloc(), new_start, n);
-            this->members_.m_start = new_start;
-         }
-         else{
-            pos = this->members_.m_start + elemsbefore;
-            if (elemsbefore >= n) {
-               const iterator start_n = this->members_.m_start + n;
+         pos = this->members_.m_start + difference_type(elemsbefore);
+         if (elemsbefore >= n) {
+            const iterator start_n = this->members_.m_start + difference_type(n);
+            BOOST_CONTAINER_TRY {
                ::boost::container::uninitialized_move_alloc
                   (this->alloc(), this->members_.m_start, start_n, new_start);
-               this->members_.m_start = new_start;
-               boost::container::move(start_n, pos, old_start);
-               proxy.copy_n_and_update(this->alloc(), pos - n, n);
             }
-            else {
-               const size_type mid_count = n - elemsbefore;
-               const iterator mid_start = old_start - mid_count;
+            BOOST_CONTAINER_CATCH(...) {
+               this->priv_destroy_nodes(new_start.m_node, this->members_.m_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);
+         }
+         else {
+            const size_type mid_count = n - elemsbefore;
+            const 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->members_.m_start = new_start;
-               proxy.copy_n_and_update(this->alloc(), old_start, elemsbefore);
+               ::boost::container::uninitialized_move_alloc(this->alloc(), old_start, pos, new_start);
+            }
+            BOOST_CONTAINER_CATCH(...) {
+               this->priv_destroy_nodes(new_start.m_node, this->members_.m_start.m_node);
+               BOOST_CONTAINER_RETHROW
             }
+            BOOST_CONTAINER_CATCH_END
+            this->members_.m_start = new_start;
+            proxy.copy_n_and_update(this->alloc(), old_start, elemsbefore);
          }
       }
       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;
-         if(!elemsafter){
-            proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, n);
+
+         pos = old_finish - difference_type(elemsafter);
+         if (elemsafter >= n) {
+            iterator finish_n = old_finish - difference_type(n);
+            BOOST_CONTAINER_TRY {
+               ::boost::container::uninitialized_move_alloc(this->alloc(), finish_n, old_finish, old_finish);
+            }
+            BOOST_CONTAINER_CATCH(...) {
+               this->priv_destroy_nodes(this->members_.m_finish.m_node + 1, new_finish.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);
          }
-         else{
-            pos = old_finish - elemsafter;
-            if (elemsafter >= n) {
-               iterator finish_n = old_finish - difference_type(n);
-               ::boost::container::uninitialized_move_alloc
-                  (this->alloc(), finish_n, old_finish, old_finish);
-               this->members_.m_finish = new_finish;
-               boost::container::move_backward(pos, finish_n, old_finish);
-               proxy.copy_n_and_update(this->alloc(), pos, n);
-            }
-            else {
-               const size_type raw_gap = n - elemsafter;
+         else {
+            const size_type raw_gap = n - elemsafter;
+            BOOST_CONTAINER_TRY{
                ::boost::container::uninitialized_move_alloc
-                  (this->alloc(), pos, old_finish, old_finish + raw_gap);
-               BOOST_TRY{
+                  (this->alloc(), pos, old_finish, 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);
                }
-               BOOST_CATCH(...){
-                  this->priv_destroy_range(old_finish, old_finish + elemsafter);
-                  BOOST_RETHROW
+               BOOST_CONTAINER_CATCH(...) {
+                  this->priv_destroy_range(old_finish, old_finish + difference_type(elemsafter));
+                  BOOST_CONTAINER_RETHROW
                }
-               BOOST_CATCH_END
-               this->members_.m_finish = new_finish;
+               BOOST_CONTAINER_CATCH_END
             }
+            BOOST_CONTAINER_CATCH(...) {
+               this->priv_destroy_nodes(this->members_.m_finish.m_node + 1, new_finish.m_node + 1);
+               BOOST_CONTAINER_RETHROW
+            }
+            BOOST_CONTAINER_CATCH_END
+            this->members_.m_finish = new_finish;
          }
       }
-      return this->begin() + pos_n;
+      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();
+
+      if (!elemsbefore) {
+         return this->priv_insert_front_aux_impl(n, proxy);
+      }
+      else if (elemsbefore == length) {
+         return this->priv_insert_back_aux_impl(n, proxy);
+      }
+      else {
+         return this->priv_insert_middle_aux_impl(p, elemsbefore, length, n, proxy);
+      }
    }
 
    template <class InsertProxy>
@@ -2134,10 +2645,16 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       }
 
       iterator new_finish = this->priv_reserve_elements_at_back(n);
-      iterator old_finish = this->members_.m_finish;
-      proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, 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
+      }
+      BOOST_CONTAINER_CATCH_END
       this->members_.m_finish = new_finish;
-      return iterator(this->members_.m_finish - n);
+      return iterator(this->members_.m_finish - difference_type(n));
    }
 
    template <class InsertProxy>
@@ -2148,14 +2665,21 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       }
 
       iterator new_start = this->priv_reserve_elements_at_front(n);
-      proxy.uninitialized_copy_n_and_update(this->alloc(), new_start, n);
+      BOOST_CONTAINER_TRY{
+         proxy.uninitialized_copy_n_and_update(this->alloc(), new_start, n);
+      }
+      BOOST_CONTAINER_CATCH(...) {
+         this->priv_destroy_nodes(new_start.m_node, this->members_.m_start.m_node);
+         BOOST_CONTAINER_RETHROW
+      }
+      BOOST_CONTAINER_CATCH_END
+
       this->members_.m_start = new_start;
       return new_start;
    }
 
-   BOOST_CONTAINER_FORCEINLINE iterator priv_fill_insert(const_iterator pos, size_type n, const value_type& x)
+   inline iterator priv_fill_insert(const_iterator pos, size_type n, const value_type& x)
    {
-      typedef constant_iterator<value_type, difference_type> c_it;
       return this->insert(pos, c_it(x, n), c_it());
    }
 
@@ -2164,75 +2688,75 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    void priv_fill_initialize(const value_type& value)
    {
       index_pointer cur = this->members_.m_start.m_node;
-      BOOST_TRY {
+      BOOST_CONTAINER_TRY {
          for ( ; cur < this->members_.m_finish.m_node; ++cur){
             boost::container::uninitialized_fill_alloc
-               (this->alloc(), *cur, *cur + get_block_size(), value);
+               (this->alloc(), *cur, *cur + get_block_ssize(), value);
          }
          boost::container::uninitialized_fill_alloc
-            (this->alloc(), this->members_.m_finish.m_first, this->members_.m_finish.m_cur, value);
+            (this->alloc(), this->members_.m_finish.get_first(), this->members_.m_finish.m_cur, value);
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->priv_destroy_range(this->members_.m_start, iterator(*cur, cur, get_block_size()));
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    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_TRY {
+      BOOST_CONTAINER_TRY {
          for ( ; first != last; ++first)
             this->emplace_back(*first);
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->clear();
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    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_distance(first, last);
+      n = boost::container::iterator_udistance(first, last);
       this->priv_initialize_map(n);
 
       index_pointer cur_node = this->members_.m_start.m_node;
-      BOOST_TRY {
+      BOOST_CONTAINER_TRY {
          for (; cur_node < this->members_.m_finish.m_node; ++cur_node) {
             FwdIt mid = first;
-            boost::container::iterator_advance(mid, get_block_size());
+            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.m_first);
+         ::boost::container::uninitialized_copy_alloc(this->alloc(), first, last, this->members_.m_finish.get_first());
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->priv_destroy_range(this->members_.m_start, iterator(*cur_node, cur_node, get_block_size()));
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
-   // Called only if this->members_.m_finish.m_cur == this->members_.m_finish.m_first.
+   // Called only if this->members_.m_finish.m_cur == this->members_.m_finish.get_first().
    void priv_pop_back_aux() BOOST_NOEXCEPT_OR_NOTHROW
    {
-      this->priv_deallocate_node(this->members_.m_finish.m_first);
+      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.m_last - 1;
+      this->members_.m_finish.m_cur = this->members_.m_finish.get_last() - 1;
       allocator_traits_type::destroy
          ( this->alloc()
          , boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur)
          );
    }
 
-   // Called only if this->members_.m_start.m_cur == this->members_.m_start.m_last - 1.  Note that
+   // Called only if this->members_.m_start.m_cur == this->members_.m_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.m_last, then the deque
+   // function), and if this->members_.m_start.m_cur == this->members_.m_start.get_last(), then the deque
    // must have at least two nodes.
    void priv_pop_front_aux() BOOST_NOEXCEPT_OR_NOTHROW
    {
@@ -2240,84 +2764,83 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          ( this->alloc()
          , boost::movelib::to_raw_pointer(this->members_.m_start.m_cur)
          );
-      this->priv_deallocate_node(this->members_.m_start.m_first);
+      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.m_first;
+      this->members_.m_start.m_cur = this->members_.m_start.get_first();
    }
 
    iterator priv_reserve_elements_at_front(size_type n)
    {
-      size_type vacancies = this->members_.m_start.m_cur - this->members_.m_start.m_first;
+      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() - 1) /
-            get_block_size();
+         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_TRY {
+         BOOST_CONTAINER_TRY {
             for (; i <= new_nodes; ++i)
-               *(this->members_.m_start.m_node - i) = this->priv_allocate_node();
+               *(this->members_.m_start.m_node - difference_type(i)) = this->priv_allocate_node();
          }
-         BOOST_CATCH(...) {
+         BOOST_CONTAINER_CATCH(...) {
             for (size_type j = 1; j < i; ++j)
-               this->priv_deallocate_node(*(this->members_.m_start.m_node - j));
-            BOOST_RETHROW
+               this->priv_deallocate_node(*(this->members_.m_start.m_node - difference_type(j)));
+            BOOST_CONTAINER_RETHROW
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
       }
       return this->members_.m_start - difference_type(n);
    }
 
    iterator priv_reserve_elements_at_back(size_type n)
    {
-      size_type vacancies = (this->members_.m_finish.m_last - this->members_.m_finish.m_cur) - 1;
+      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 = n - vacancies;
-         size_type new_nodes = (new_elems + get_block_size() - 1)/get_block_size();
-         size_type s = (size_type)(this->members_.m_map_size - (this->members_.m_finish.m_node - this->members_.m_map));
+         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_TRY {
+         BOOST_CONTAINER_TRY {
             for (; i <= new_nodes; ++i)
-               *(this->members_.m_finish.m_node + i) = this->priv_allocate_node();
+               *(this->members_.m_finish.m_node + difference_type(i)) = this->priv_allocate_node();
          }
-         BOOST_CATCH(...) {
+         BOOST_CONTAINER_CATCH(...) {
             for (size_type j = 1; j < i; ++j)
-               this->priv_deallocate_node(*(this->members_.m_finish.m_node + j));
-            BOOST_RETHROW
+               this->priv_deallocate_node(*(this->members_.m_finish.m_node + difference_type(j)));
+            BOOST_CONTAINER_RETHROW
          }
-         BOOST_CATCH_END
+         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 = this->members_.m_finish.m_node - this->members_.m_start.m_node + 1;
+      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 + (this->members_.m_map_size - new_num_nodes) / 2
-                           + (add_at_front ? nodes_to_add : 0);
+         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 + old_num_nodes);
+               (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 + (new_map_size - new_num_nodes) / 2
-                              + (add_at_front ? nodes_to_add : 0);
+         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);
 
@@ -2326,7 +2849,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       }
 
       this->members_.m_start.priv_set_node(new_nstart, get_block_size());
-      this->members_.m_finish.priv_set_node(new_nstart + old_num_nodes - 1, 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
 };
@@ -2338,7 +2861,8 @@ template <typename InputIterator, typename Allocator>
 deque(InputIterator, InputIterator, Allocator const&) -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
 #endif
 
-}}
+}  //namespace container
+}  //namespace boost
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -2351,7 +2875,7 @@ struct has_trivial_destructor_after_move<boost::container::deque<T, Allocator, O
 {
    typedef typename boost::container::deque<T, Allocator, Options>::allocator_type allocator_type;
    typedef typename ::boost::container::allocator_traits<allocator_type>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<allocator_type>::value &&
+   BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<allocator_type>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value;
 };