Allow instantiation of deque and deque::iterator with incomplete value type.

[eugenis]

Friendly ping.
The diff is big, but all the changes are mechanical: all I did was move __block_size calculation inside method bodies to avoid evaluating it during class instantiation.

[eugenis]

On a second thought, does this change break ABI stability?
I really don't understand what could break though, seeing that the change is header-only and does not affect libc++.so at all.

[eugenis]

On a third thought, it does break ABI stability. We've got
sizeof(element) baked into deque::iterator mangled name! Does it mean
we are doomed and there is no way to achieve this?

[EricWF]

Ooohh... Your right. It does seem to change the mangled name of std::deque::iterator. libc++ needs to quickly figure out how we want to manage ABI changes. I'll bring this up with @mclow.lists at the end of next week.

[mclow.lists]

I don't want to close this, but we're not going to apply it anytime soon, either.
[ Due to the ABI breakage ]

[eugenis]

It looks like the right solution for this problem is starting a __2 namespace and duplicating the whole deque header there (because the changes are so pervasive). How does that sound? I'd like to work on that. Any advice would be much appreciated.

[rsmith]

I put together a different possible approach at http://reviews.llvm.org/D10677. The idea is to keep the old and new ABI versions as similar as possible, by filling in the last template argument of the iterator type with 0 in the new ABI. That template parameter becomes (essentially) meaningless, and both the old and new ABI use a different mechanism to get the block size when they need it.

[eugenis]

Abandoned in favor of http://reviews.llvm.org/D10677.

include/deque

 
 #include <__undef_min_max>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Allocator> class __deque_base;
 template <class _Tp, class _Allocator = allocator<_Tp> > class _LIBCPP_TYPE_VIS_ONLY deque;
 
+template<class value_type, class difference_type>
+struct __calculate_block_size {
+  static const difference_type __block_size = sizeof(value_type) < 256 ? 4096 / sizeof(value_type) : 16;
+};
+
 template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
-          class _DiffType, _DiffType _BlockSize>
+          class _DiffType>
 class _LIBCPP_TYPE_VIS_ONLY __deque_iterator;
 
 template <class _RAIter,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
 copy(_RAIter __f,
      _RAIter __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+     __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
      typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _OutputIterator>
 _OutputIterator
-copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-     __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+     __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
      _OutputIterator __r);
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-     __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
+copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+     __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+     __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r);
 
 template <class _RAIter,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
 copy_backward(_RAIter __f,
               _RAIter __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+              __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
               typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _OutputIterator>
 _OutputIterator
-copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-              __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+              __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
               _OutputIterator __r);
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-              __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
+copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+              __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+              __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r);
 
 template <class _RAIter,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
 move(_RAIter __f,
      _RAIter __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+     __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
      typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _OutputIterator>
 _OutputIterator
-move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-     __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+move(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+     __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
      _OutputIterator __r);
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-     __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
+move(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+     __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+     __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r);
 
 template <class _RAIter,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
 move_backward(_RAIter __f,
               _RAIter __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+              __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
               typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _OutputIterator>
 _OutputIterator
-move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-              __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+              __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
               _OutputIterator __r);
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-              __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
+move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+              __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+              __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r);
 
 template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
-          class _DiffType, _DiffType _BlockSize>
+          class _DiffType>
 class _LIBCPP_TYPE_VIS_ONLY __deque_iterator
 {
     typedef _MapPointer __map_iterator;
 public:
     typedef _Pointer  pointer;
     typedef _DiffType difference_type;
 private:
     __map_iterator __m_iter_;
     pointer        __ptr_;
-
-    static const difference_type __block_size = _BlockSize;
+    typedef __calculate_block_size<_ValueType, difference_type> __value_traits;
 public:
     typedef _ValueType                  value_type;
     typedef random_access_iterator_tag  iterator_category;
     typedef _Reference                  reference;
 
     _LIBCPP_INLINE_VISIBILITY __deque_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER > 11
      : __m_iter_(nullptr), __ptr_(nullptr)
 #endif
      {}
 
     template <class _Pp, class _Rp, class _MP>
     _LIBCPP_INLINE_VISIBILITY
-    __deque_iterator(const __deque_iterator<value_type, _Pp, _Rp, _MP, difference_type, __block_size>& __it,
+    __deque_iterator(const __deque_iterator<value_type, _Pp, _Rp, _MP, difference_type>& __it,
                 typename enable_if<is_convertible<_Pp, pointer>::value>::type* = 0) _NOEXCEPT
         : __m_iter_(__it.__m_iter_), __ptr_(__it.__ptr_) {}
 
     _LIBCPP_INLINE_VISIBILITY reference operator*() const {return *__ptr_;}
     _LIBCPP_INLINE_VISIBILITY pointer operator->() const {return __ptr_;}
 
     _LIBCPP_INLINE_VISIBILITY __deque_iterator& operator++()
     {
-        if (++__ptr_ - *__m_iter_ == __block_size)
+        if (++__ptr_ - *__m_iter_ == __value_traits::__block_size)
         {
             ++__m_iter_;
             __ptr_ = *__m_iter_;
         }
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY __deque_iterator operator++(int)
     {
         __deque_iterator __tmp = *this;
         ++(*this);
         return __tmp;
     }
 
     _LIBCPP_INLINE_VISIBILITY __deque_iterator& operator--()
     {
         if (__ptr_ == *__m_iter_)
         {
             --__m_iter_;
-            __ptr_ = *__m_iter_ + __block_size;
+            __ptr_ = *__m_iter_ + __value_traits::__block_size;
         }
         --__ptr_;
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY __deque_iterator operator--(int)
     {
         __deque_iterator __tmp = *this;
         --(*this);
         return __tmp;
     }
 
     _LIBCPP_INLINE_VISIBILITY __deque_iterator& operator+=(difference_type __n)
     {
         if (__n != 0)
         {
             __n += __ptr_ - *__m_iter_;
             if (__n > 0)
             {
-                __m_iter_ += __n / __block_size;
-                __ptr_ = *__m_iter_ + __n % __block_size;
+                __m_iter_ += __n / __value_traits::__block_size;
+                __ptr_ = *__m_iter_ + __n % __value_traits::__block_size;
             }
             else // (__n < 0)
             {
-                difference_type __z = __block_size - 1 - __n;
-                __m_iter_ -= __z / __block_size;
-                __ptr_ = *__m_iter_ + (__block_size - 1 - __z % __block_size);
+                difference_type __z = __value_traits::__block_size - 1 - __n;
+                __m_iter_ -= __z / __value_traits::__block_size;
+                __ptr_ = *__m_iter_ + (__value_traits::__block_size - 1 - __z % __value_traits::__block_size);
             }
         }
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY __deque_iterator& operator-=(difference_type __n)
     {
         return *this += -__n;
#endif
     _LIBCPP_INLINE_VISIBILITY
     friend __deque_iterator operator+(difference_type __n, const __deque_iterator& __it)
         {return __it + __n;}
 
     _LIBCPP_INLINE_VISIBILITY
     friend difference_type operator-(const __deque_iterator& __x, const __deque_iterator& __y)
     {
         if (__x != __y)
-            return (__x.__m_iter_ - __y.__m_iter_) * __block_size
+            return (__x.__m_iter_ - __y.__m_iter_) * __value_traits::__block_size
                  + (__x.__ptr_ - *__x.__m_iter_)
                  - (__y.__ptr_ - *__y.__m_iter_);
         return 0;
     }
 
     _LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const
         {return *(*this + __n);}
 
_LIBCPP_INLINE_VISIBILITY friend
         {return !(__x < __y);}
 
 private:
     _LIBCPP_INLINE_VISIBILITY __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT
         : __m_iter_(__m), __ptr_(__p) {}
 
     template <class _Tp, class _Ap> friend class __deque_base;
     template <class _Tp, class _Ap> friend class _LIBCPP_TYPE_VIS_ONLY deque;
-    template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp>
+    template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp>
         friend class _LIBCPP_TYPE_VIS_ONLY __deque_iterator;
 
     template <class _RAIter,
               class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
     friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+    __deque_iterator<_V2, _P2, _R2, _M2, _D2>
     copy(_RAIter __f,
          _RAIter __l,
-         __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+         __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
          typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);
 
     template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
               class _OutputIterator>
     friend
     _OutputIterator
-    copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-         __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+    copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+         __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
          _OutputIterator __r);
 
     template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
               class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
     friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-    copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-         __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-         __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);
+    __deque_iterator<_V2, _P2, _R2, _M2, _D2>
+    copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+         __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+         __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r);
 
     template <class _RAIter,
               class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
     friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+    __deque_iterator<_V2, _P2, _R2, _M2, _D2>
     copy_backward(_RAIter __f,
                   _RAIter __l,
-                  __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+                  __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
                   typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);
 
     template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
               class _OutputIterator>
     friend
     _OutputIterator
-    copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-                  __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+    copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+                  __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
                   _OutputIterator __r);
 
     template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
               class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
     friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-    copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-                  __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-                  __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);
+    __deque_iterator<_V2, _P2, _R2, _M2, _D2>
+    copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+                  __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+                  __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r);
 
     template <class _RAIter,
               class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
     friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+    __deque_iterator<_V2, _P2, _R2, _M2, _D2>
     move(_RAIter __f,
          _RAIter __l,
-         __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+         __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
          typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);
 
     template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
               class _OutputIterator>
     friend
     _OutputIterator
-    move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-         __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+    move(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+         __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
          _OutputIterator __r);
 
     template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
               class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
     friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-    move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-         __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-         __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);
+    __deque_iterator<_V2, _P2, _R2, _M2, _D2>
+    move(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+         __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+         __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r);
 
     template <class _RAIter,
               class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
     friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+    __deque_iterator<_V2, _P2, _R2, _M2, _D2>
     move_backward(_RAIter __f,
                   _RAIter __l,
-                  __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+                  __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
                   typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);
 
     template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
               class _OutputIterator>
     friend
     _OutputIterator
-    move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-                  __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+    move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+                  __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
                   _OutputIterator __r);
 
     template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
               class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
     friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-    move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-                  __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-                  __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);
+    __deque_iterator<_V2, _P2, _R2, _M2, _D2>
+    move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+                  __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+                  __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r);
 };
 
 // copy
 
 template <class _RAIter,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
 copy(_RAIter __f,
      _RAIter __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+     __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
      typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)
 {
-    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
-    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
+    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2>::difference_type difference_type;
+    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2>::pointer pointer;
     while (__f != __l)
     {
         pointer __rb = __r.__ptr_;
         pointer __re = *__r.__m_iter_ + _B2;
         difference_type __bs = __re - __rb;
         difference_type __n = __l - __f;
         _RAIter __m = __l;
         if (__n > __bs)
         {
             __n = __bs;
             __m = __f + __n;
         }
         _VSTD::copy(__f, __m, __rb);
         __f = __m;
         __r += __n;
     }
     return __r;
 }
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _OutputIterator>
 _OutputIterator
-copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-     __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+     __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
      _OutputIterator __r)
 {
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::difference_type difference_type;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::pointer pointer;
     difference_type __n = __l - __f;
     while (__n > 0)
     {
         pointer __fb = __f.__ptr_;
         pointer __fe = *__f.__m_iter_ + _B1;
         difference_type __bs = __fe - __fb;
         if (__bs > __n)
         {
             __bs = __n;
             __fe = __fb + __bs;
         }
         __r = _VSTD::copy(__fb, __fe, __r);
         __n -= __bs;
         __f += __bs;
     }
     return __r;
 }
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-     __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r)
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
+copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+     __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+     __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r)
 {
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::difference_type difference_type;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::pointer pointer;
     difference_type __n = __l - __f;
     while (__n > 0)
     {
         pointer __fb = __f.__ptr_;
         pointer __fe = *__f.__m_iter_ + _B1;
         difference_type __bs = __fe - __fb;
         if (__bs > __n)
         {
             __bs = __n;
             __fe = __fb + __bs;
         }
         __r = _VSTD::copy(__fb, __fe, __r);
         __n -= __bs;
         __f += __bs;
     }
     return __r;
 }
 
 // copy_backward
 
 template <class _RAIter,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
 copy_backward(_RAIter __f,
               _RAIter __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+              __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
               typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)
 {
-    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
-    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
+    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2>::difference_type difference_type;
+    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2>::pointer pointer;
     while (__f != __l)
     {
-        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _VSTD::prev(__r);
+        __deque_iterator<_V2, _P2, _R2, _M2, _D2> __rp = _VSTD::prev(__r);
         pointer __rb = *__rp.__m_iter_;
         pointer __re = __rp.__ptr_ + 1;
         difference_type __bs = __re - __rb;
         difference_type __n = __l - __f;
         _RAIter __m = __f;
         if (__n > __bs)
         {
             __n = __bs;
             __m = __l - __n;
         }
         _VSTD::copy_backward(__m, __l, __re);
         __l = __m;
         __r -= __n;
     }
     return __r;
 }
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _OutputIterator>
 _OutputIterator
-copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-              __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+              __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
               _OutputIterator __r)
 {
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::difference_type difference_type;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::pointer pointer;
     difference_type __n = __l - __f;
     while (__n > 0)
     {
         --__l;
         pointer __lb = *__l.__m_iter_;
         pointer __le = __l.__ptr_ + 1;
         difference_type __bs = __le - __lb;
         if (__bs > __n)
         {
             __bs = __n;
             __lb = __le - __bs;
         }
         __r = _VSTD::copy_backward(__lb, __le, __r);
         __n -= __bs;
         __l -= __bs - 1;
     }
     return __r;
 }
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-              __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r)
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
+copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+              __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+              __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r)
 {
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::difference_type difference_type;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::pointer pointer;
     difference_type __n = __l - __f;
     while (__n > 0)
     {
         --__l;
         pointer __lb = *__l.__m_iter_;
         pointer __le = __l.__ptr_ + 1;
         difference_type __bs = __le - __lb;
         if (__bs > __n)
         {
             __bs = __n;
             __lb = __le - __bs;
         }
         __r = _VSTD::copy_backward(__lb, __le, __r);
         __n -= __bs;
         __l -= __bs - 1;
     }
     return __r;
 }
 
 // move
 
 template <class _RAIter,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
 move(_RAIter __f,
      _RAIter __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+     __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
      typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)
 {
-    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
-    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
+    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2>::difference_type difference_type;
+    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2>::pointer pointer;
     while (__f != __l)
     {
         pointer __rb = __r.__ptr_;
         pointer __re = *__r.__m_iter_ + _B2;
         difference_type __bs = __re - __rb;
         difference_type __n = __l - __f;
         _RAIter __m = __l;
         if (__n > __bs)
         {
             __n = __bs;
             __m = __f + __n;
         }
         _VSTD::move(__f, __m, __rb);
         __f = __m;
         __r += __n;
     }
     return __r;
 }
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _OutputIterator>
 _OutputIterator
-move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-     __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+move(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+     __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
      _OutputIterator __r)
 {
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::difference_type difference_type;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::pointer pointer;
     difference_type __n = __l - __f;
     while (__n > 0)
     {
         pointer __fb = __f.__ptr_;
         pointer __fe = *__f.__m_iter_ + _B1;
         difference_type __bs = __fe - __fb;
         if (__bs > __n)
         {
             __bs = __n;
             __fe = __fb + __bs;
         }
         __r = _VSTD::move(__fb, __fe, __r);
         __n -= __bs;
         __f += __bs;
     }
     return __r;
 }
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-     __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r)
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
+move(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+     __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+     __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r)
 {
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::difference_type difference_type;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::pointer pointer;
     difference_type __n = __l - __f;
     while (__n > 0)
     {
         pointer __fb = __f.__ptr_;
         pointer __fe = *__f.__m_iter_ + _B1;
         difference_type __bs = __fe - __fb;
         if (__bs > __n)
         {
             __bs = __n;
             __fe = __fb + __bs;
         }
         __r = _VSTD::move(__fb, __fe, __r);
         __n -= __bs;
         __f += __bs;
     }
     return __r;
 }
 
 // move_backward
 
 template <class _RAIter,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
 move_backward(_RAIter __f,
               _RAIter __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+              __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r,
               typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)
 {
-    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
-    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
+    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2>::difference_type difference_type;
+    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2>::pointer pointer;
     while (__f != __l)
     {
-        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _VSTD::prev(__r);
+        __deque_iterator<_V2, _P2, _R2, _M2, _D2> __rp = _VSTD::prev(__r);
         pointer __rb = *__rp.__m_iter_;
         pointer __re = __rp.__ptr_ + 1;
         difference_type __bs = __re - __rb;
         difference_type __n = __l - __f;
         _RAIter __m = __f;
         if (__n > __bs)
         {
             __n = __bs;
             __m = __l - __n;
         }
         _VSTD::move_backward(__m, __l, __re);
         __l = __m;
         __r -= __n;
     }
     return __r;
 }
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _OutputIterator>
 _OutputIterator
-move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-              __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
+move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+              __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
               _OutputIterator __r)
 {
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::difference_type difference_type;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::pointer pointer;
     difference_type __n = __l - __f;
     while (__n > 0)
     {
         --__l;
         pointer __lb = *__l.__m_iter_;
         pointer __le = __l.__ptr_ + 1;
         difference_type __bs = __le - __lb;
         if (__bs > __n)
         {
             __bs = __n;
             __lb = __le - __bs;
         }
         __r = _VSTD::move_backward(__lb, __le, __r);
         __n -= __bs;
         __l -= __bs - 1;
     }
     return __r;
 }
 
 template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
           class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
-              __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r)
+__deque_iterator<_V2, _P2, _R2, _M2, _D2>
+move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1> __f,
+              __deque_iterator<_V1, _P1, _R1, _M1, _D1> __l,
+              __deque_iterator<_V2, _P2, _R2, _M2, _D2> __r)
 {
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
-    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::difference_type difference_type;
+    typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1>::pointer pointer;
     difference_type __n = __l - __f;
     while (__n > 0)
     {
         --__l;
         pointer __lb = *__l.__m_iter_;
         pointer __le = __l.__ptr_ + 1;
         difference_type __bs = __le - __lb;
         if (__bs > __n)
protected:
     typedef _Allocator                               allocator_type;
     typedef allocator_traits<allocator_type>         __alloc_traits;
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
     typedef typename __alloc_traits::size_type       size_type;
     typedef typename __alloc_traits::difference_type difference_type;
     typedef typename __alloc_traits::pointer         pointer;
     typedef typename __alloc_traits::const_pointer   const_pointer;
-
-    static const difference_type __block_size = sizeof(value_type) < 256 ? 4096 / sizeof(value_type) : 16;
+    typedef __calculate_block_size<value_type, difference_type> __value_traits;
 
     typedef typename __rebind_alloc_helper<__alloc_traits, pointer>::type __pointer_allocator;
     typedef allocator_traits<__pointer_allocator>        __map_traits;
     typedef typename __map_traits::pointer               __map_pointer;
     typedef typename __rebind_alloc_helper<__alloc_traits, const_pointer>::type __const_pointer_allocator;
     typedef typename allocator_traits<__const_pointer_allocator>::const_pointer __map_const_pointer;
     typedef __split_buffer<pointer, __pointer_allocator> __map;
 
     typedef __deque_iterator<value_type, pointer, reference, __map_pointer,
-                             difference_type, __block_size>    iterator;
+                             difference_type>    iterator;
     typedef __deque_iterator<value_type, const_pointer, const_reference, __map_const_pointer,
-                             difference_type, __block_size>    const_iterator;
+                             difference_type>    const_iterator;
 
     __map __map_;
     size_type __start_;
     __compressed_pair<size_type, allocator_type> __size_;
 
     iterator       begin() _NOEXCEPT;
     const_iterator begin() const _NOEXCEPT;
     iterator       end() _NOEXCEPT;

 };
 
 template <class _Tp, class _Allocator>
 bool
 __deque_base<_Tp, _Allocator>::__invariants() const
 {
     if (!__map_.__invariants())
         return false;
-    if (__map_.size() >= size_type(-1) / __block_size)
+    if (__map_.size() >= size_type(-1) / __value_traits::__block_size)
         return false;
     for (typename __map::const_iterator __i = __map_.begin(), __e = __map_.end();
          __i != __e; ++__i)
         if (*__i == nullptr)
             return false;
     if (__map_.size() != 0)
     {
-        if (size() >= __map_.size() * __block_size)
+        if (size() >= __map_.size() * __value_traits::__block_size)
             return false;
-        if (__start_ >= __map_.size() * __block_size - size())
+        if (__start_ >= __map_.size() * __value_traits::__block_size - size())
             return false;
     }
     else
     {
         if (size() != 0)
             return false;
         if (__start_ != 0)
             return false;
     }
     return true;
 }
 
 template <class _Tp, class _Allocator>
 typename __deque_base<_Tp, _Allocator>::iterator
 __deque_base<_Tp, _Allocator>::begin() _NOEXCEPT
 {
-    __map_pointer __mp = __map_.begin() + __start_ / __block_size;
-    return iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);
+    __map_pointer __mp = __map_.begin() + __start_ / __value_traits::__block_size;
+    return iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 typename __deque_base<_Tp, _Allocator>::const_iterator
 __deque_base<_Tp, _Allocator>::begin() const _NOEXCEPT
 {
-    __map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __start_ / __block_size);
-    return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);
+    __map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __start_ / __value_traits::__block_size);
+    return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 typename __deque_base<_Tp, _Allocator>::iterator
 __deque_base<_Tp, _Allocator>::end() _NOEXCEPT
 {
     size_type __p = size() + __start_;
-    __map_pointer __mp = __map_.begin() + __p / __block_size;
-    return iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
+    __map_pointer __mp = __map_.begin() + __p / __value_traits::__block_size;
+    return iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 typename __deque_base<_Tp, _Allocator>::const_iterator
 __deque_base<_Tp, _Allocator>::end() const _NOEXCEPT
 {
     size_type __p = size() + __start_;
-    __map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __block_size);
-    return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
+    __map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __value_traits::__block_size);
+    return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 __deque_base<_Tp, _Allocator>::__deque_base()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __start_(0), __size_(0) {}
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 __deque_base<_Tp, _Allocator>::__deque_base(const allocator_type& __a)
     : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {}
 
 template <class _Tp, class _Allocator>
 __deque_base<_Tp, _Allocator>::~__deque_base()
 {
     clear();
     typename __map::iterator __i = __map_.begin();
     typename __map::iterator __e = __map_.end();
     for (; __i != __e; ++__i)
-        __alloc_traits::deallocate(__alloc(), *__i, __block_size);
+        __alloc_traits::deallocate(__alloc(), *__i, __value_traits::__block_size);
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Allocator>
 __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
     : __map_(_VSTD::move(__c.__map_)),

 __deque_base<_Tp, _Allocator>::clear() _NOEXCEPT
 {
     allocator_type& __a = __alloc();
     for (iterator __i = begin(), __e = end(); __i != __e; ++__i)
         __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
     size() = 0;
     while (__map_.size() > 2)
     {
-        __alloc_traits::deallocate(__a, __map_.front(), __block_size);
+        __alloc_traits::deallocate(__a, __map_.front(), __value_traits::__block_size);
         __map_.pop_front();
     }
     switch (__map_.size())
     {
     case 1:
-        __start_ = __block_size / 2;
+        __start_ = __value_traits::__block_size / 2;
         break;
     case 2:
-        __start_ = __block_size;
+        __start_ = __value_traits::__block_size;
         break;
     }
 }
 
 template <class _Tp, class _Allocator /*= allocator<_Tp>*/>
 class _LIBCPP_TYPE_VIS_ONLY deque
     : private __deque_base<_Tp, _Allocator>
 {
public:
     typedef typename __base::size_type             size_type;
     typedef typename __base::difference_type       difference_type;
 
     typedef typename __base::pointer               pointer;
     typedef typename __base::const_pointer         const_pointer;
     typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
     typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
 
+private:
+  typedef __calculate_block_size<value_type, difference_type> __value_traits;
+public:
+
     // construct/copy/destroy:
     _LIBCPP_INLINE_VISIBILITY
     deque()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
         {}
     _LIBCPP_INLINE_VISIBILITY explicit deque(const allocator_type& __a) : __base(__a) {}
     explicit deque(size_type __n);
 #if _LIBCPP_STD_VER > 11
#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
     bool __invariants() const {return __base::__invariants();}
 private:
     typedef typename __base::__map_const_pointer __map_const_pointer;
 
     _LIBCPP_INLINE_VISIBILITY
     static size_type __recommend_blocks(size_type __n)
     {
-        return __n / __base::__block_size + (__n % __base::__block_size != 0);
+        return __n / __value_traits::__block_size + (__n % __value_traits::__block_size != 0);
     }
     _LIBCPP_INLINE_VISIBILITY
     size_type __capacity() const
     {
-        return __base::__map_.size() == 0 ? 0 : __base::__map_.size() * __base::__block_size - 1;
+        return __base::__map_.size() == 0 ? 0 : __base::__map_.size() * __value_traits::__block_size - 1;
     }
     _LIBCPP_INLINE_VISIBILITY
     size_type __front_spare() const
     {
         return __base::__start_;
     }
     _LIBCPP_INLINE_VISIBILITY
     size_type __back_spare() const

 void
 deque<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
 {
     allocator_type& __a = __base::__alloc();
     if (empty())
     {
         while (__base::__map_.size() > 0)
         {
-            __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
+            __alloc_traits::deallocate(__a, __base::__map_.back(), __value_traits::__block_size);
             __base::__map_.pop_back();
         }
         __base::__start_ = 0;
     }
     else
     {
-        if (__front_spare() >= __base::__block_size)
+        if (__front_spare() >= __value_traits::__block_size)
         {
-            __alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
+            __alloc_traits::deallocate(__a, __base::__map_.front(), __value_traits::__block_size);
             __base::__map_.pop_front();
-            __base::__start_ -= __base::__block_size;
+            __base::__start_ -= __value_traits::__block_size;
         }
-        if (__back_spare() >= __base::__block_size)
+        if (__back_spare() >= __value_traits::__block_size)
         {
-            __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
+            __alloc_traits::deallocate(__a, __base::__map_.back(), __value_traits::__block_size);
             __base::__map_.pop_back();
         }
     }
     __base::__map_.shrink_to_fit();
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename deque<_Tp, _Allocator>::reference
 deque<_Tp, _Allocator>::operator[](size_type __i)
 {
     size_type __p = __base::__start_ + __i;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+    return *(*(__base::__map_.begin() + __p / __value_traits::__block_size) + __p % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename deque<_Tp, _Allocator>::const_reference
 deque<_Tp, _Allocator>::operator[](size_type __i) const
 {
     size_type __p = __base::__start_ + __i;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+    return *(*(__base::__map_.begin() + __p / __value_traits::__block_size) + __p % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename deque<_Tp, _Allocator>::reference
 deque<_Tp, _Allocator>::at(size_type __i)
 {
     if (__i >= __base::size())
         __base::__throw_out_of_range();
     size_type __p = __base::__start_ + __i;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+    return *(*(__base::__map_.begin() + __p / __value_traits::__block_size) + __p % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename deque<_Tp, _Allocator>::const_reference
 deque<_Tp, _Allocator>::at(size_type __i) const
 {
     if (__i >= __base::size())
         __base::__throw_out_of_range();
     size_type __p = __base::__start_ + __i;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+    return *(*(__base::__map_.begin() + __p / __value_traits::__block_size) + __p % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename deque<_Tp, _Allocator>::reference
 deque<_Tp, _Allocator>::front()
 {
-    return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size)
-                                      + __base::__start_ % __base::__block_size);
+    return *(*(__base::__map_.begin() + __base::__start_ / __value_traits::__block_size)
+                                      + __base::__start_ % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename deque<_Tp, _Allocator>::const_reference
 deque<_Tp, _Allocator>::front() const
 {
-    return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size)
-                                      + __base::__start_ % __base::__block_size);
+    return *(*(__base::__map_.begin() + __base::__start_ / __value_traits::__block_size)
+                                      + __base::__start_ % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename deque<_Tp, _Allocator>::reference
 deque<_Tp, _Allocator>::back()
 {
     size_type __p = __base::size() + __base::__start_ - 1;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+    return *(*(__base::__map_.begin() + __p / __value_traits::__block_size) + __p % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename deque<_Tp, _Allocator>::const_reference
 deque<_Tp, _Allocator>::back() const
 {
     size_type __p = __base::size() + __base::__start_ - 1;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+    return *(*(__base::__map_.begin() + __p / __value_traits::__block_size) + __p % __value_traits::__block_size);
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::push_back(const value_type& __v)
 {
     allocator_type& __a = __base::__alloc();
     if (__back_spare() == 0)

 
 // Create front capacity for one block of elements.
 // Strong guarantee.  Either do it or don't touch anything.
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__add_front_capacity()
 {
     allocator_type& __a = __base::__alloc();
-    if (__back_spare() >= __base::__block_size)
+    if (__back_spare() >= __value_traits::__block_size)
     {
-        __base::__start_ += __base::__block_size;
+        __base::__start_ += __value_traits::__block_size;
         pointer __pt = __base::__map_.back();
         __base::__map_.pop_back();
         __base::__map_.push_front(__pt);
     }
     // Else if __base::__map_.size() < __base::__map_.capacity() then we need to allocate 1 buffer
     else if (__base::__map_.size() < __base::__map_.capacity())
     {   // we can put the new buffer into the map, but don't shift things around
         // until all buffers are allocated.  If we throw, we don't need to fix
         // anything up (any added buffers are undetectible)
         if (__base::__map_.__front_spare() > 0)
-            __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
+            __base::__map_.push_front(__alloc_traits::allocate(__a, __value_traits::__block_size));
         else
         {
-            __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
+            __base::__map_.push_back(__alloc_traits::allocate(__a, __value_traits::__block_size));
             // Done allocating, reorder capacity
             pointer __pt = __base::__map_.back();
             __base::__map_.pop_back();
             __base::__map_.push_front(__pt);
         }
         __base::__start_ = __base::__map_.size() == 1 ?
-                               __base::__block_size / 2 :
-                               __base::__start_ + __base::__block_size;
+                               __value_traits::__block_size / 2 :
+                               __base::__start_ + __value_traits::__block_size;
     }
     // Else need to allocate 1 buffer, *and* we need to reallocate __map_.
     else
     {
         __split_buffer<pointer, typename __base::__pointer_allocator&>
             __buf(max<size_type>(2 * __base::__map_.capacity(), 1),
                   0, __base::__map_.__alloc());
 
     typedef __allocator_destructor<_Allocator> _Dp;
     unique_ptr<pointer, _Dp> __hold(
-      __alloc_traits::allocate(__a, __base::__block_size),
-        _Dp(__a, __base::__block_size));
+      __alloc_traits::allocate(__a, __value_traits::__block_size),
+        _Dp(__a, __value_traits::__block_size));
     __buf.push_back(__hold.get());
     __hold.release();
   
         for (typename __base::__map_pointer __i = __base::__map_.begin();
                 __i != __base::__map_.end(); ++__i)
             __buf.push_back(*__i);
         _VSTD::swap(__base::__map_.__first_, __buf.__first_);
         _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
         _VSTD::swap(__base::__map_.__end_, __buf.__end_);
         _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
         __base::__start_ = __base::__map_.size() == 1 ?
-                               __base::__block_size / 2 :
-                               __base::__start_ + __base::__block_size;
+                               __value_traits::__block_size / 2 :
+                               __base::__start_ + __value_traits::__block_size;
     }
 }
 
 // Create front capacity for __n elements.
 // Strong guarantee.  Either do it or don't touch anything.
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
 {
     allocator_type& __a = __base::__alloc();
     size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
     // Number of unused blocks at back:
-    size_type __back_capacity = __back_spare() / __base::__block_size;
+    size_type __back_capacity = __back_spare() / __value_traits::__block_size;
     __back_capacity = _VSTD::min(__back_capacity, __nb);  // don't take more than you need
     __nb -= __back_capacity;  // number of blocks need to allocate
     // If __nb == 0, then we have sufficient capacity.
     if (__nb == 0)
     {
-        __base::__start_ += __base::__block_size * __back_capacity;
+        __base::__start_ += __value_traits::__block_size * __back_capacity;
         for (; __back_capacity > 0; --__back_capacity)
         {
             pointer __pt = __base::__map_.back();
             __base::__map_.pop_back();
             __base::__map_.push_front(__pt);
         }
     }
     // Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
     else if (__nb <= __base::__map_.capacity() - __base::__map_.size())
     {   // we can put the new buffers into the map, but don't shift things around
         // until all buffers are allocated.  If we throw, we don't need to fix
         // anything up (any added buffers are undetectible)
-        for (; __nb > 0; --__nb, __base::__start_ += __base::__block_size - (__base::__map_.size() == 1))
+        for (; __nb > 0; --__nb, __base::__start_ += __value_traits::__block_size - (__base::__map_.size() == 1))
         {
             if (__base::__map_.__front_spare() == 0)
                 break;
-            __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
+            __base::__map_.push_front(__alloc_traits::allocate(__a, __value_traits::__block_size));
         }
         for (; __nb > 0; --__nb, ++__back_capacity)
-            __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
+            __base::__map_.push_back(__alloc_traits::allocate(__a, __value_traits::__block_size));
         // Done allocating, reorder capacity
-        __base::__start_ += __back_capacity * __base::__block_size;
+        __base::__start_ += __back_capacity * __value_traits::__block_size;
         for (; __back_capacity > 0; --__back_capacity)
         {
             pointer __pt = __base::__map_.back();
             __base::__map_.pop_back();
             __base::__map_.push_front(__pt);
         }
     }
     // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
     else
     {
-        size_type __ds = (__nb + __back_capacity) * __base::__block_size - __base::__map_.empty();
+        size_type __ds = (__nb + __back_capacity) * __value_traits::__block_size - __base::__map_.empty();
         __split_buffer<pointer, typename __base::__pointer_allocator&>
             __buf(max<size_type>(2* __base::__map_.capacity(),
                                  __nb + __base::__map_.size()),
                   0, __base::__map_.__alloc());
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (; __nb > 0; --__nb)
-                __buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
+                __buf.push_back(__alloc_traits::allocate(__a, __value_traits::__block_size));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
             for (typename __base::__map_pointer __i = __buf.begin();
                     __i != __buf.end(); ++__i)
-                __alloc_traits::deallocate(__a, *__i, __base::__block_size);
+                __alloc_traits::deallocate(__a, *__i, __value_traits::__block_size);
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
         for (; __back_capacity > 0; --__back_capacity)
         {
             __buf.push_back(__base::__map_.back());
             __base::__map_.pop_back();
         }

 
 // Create back capacity for one block of elements.
 // Strong guarantee.  Either do it or don't touch anything.
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__add_back_capacity()
 {
     allocator_type& __a = __base::__alloc();
-    if (__front_spare() >= __base::__block_size)
+    if (__front_spare() >= __value_traits::__block_size)
     {
-        __base::__start_ -= __base::__block_size;
+        __base::__start_ -= __value_traits::__block_size;
         pointer __pt = __base::__map_.front();
         __base::__map_.pop_front();
         __base::__map_.push_back(__pt);
     }
     // Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
     else if (__base::__map_.size() < __base::__map_.capacity())
     {   // we can put the new buffer into the map, but don't shift things around
         // until it is allocated.  If we throw, we don't need to fix
         // anything up (any added buffers are undetectible)
         if (__base::__map_.__back_spare() != 0)
-            __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
+            __base::__map_.push_back(__alloc_traits::allocate(__a, __value_traits::__block_size));
         else
         {
-            __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
+            __base::__map_.push_front(__alloc_traits::allocate(__a, __value_traits::__block_size));
             // Done allocating, reorder capacity
             pointer __pt = __base::__map_.front();
             __base::__map_.pop_front();
             __base::__map_.push_back(__pt);
         }
     }
     // Else need to allocate 1 buffer, *and* we need to reallocate __map_.
     else
     {
         __split_buffer<pointer, typename __base::__pointer_allocator&>
             __buf(max<size_type>(2* __base::__map_.capacity(), 1),
                   __base::__map_.size(),
                   __base::__map_.__alloc());
 
     typedef __allocator_destructor<_Allocator> _Dp;
     unique_ptr<pointer, _Dp> __hold(
-      __alloc_traits::allocate(__a, __base::__block_size),
-        _Dp(__a, __base::__block_size));
+      __alloc_traits::allocate(__a, __value_traits::__block_size),
+        _Dp(__a, __value_traits::__block_size));
     __buf.push_back(__hold.get());
     __hold.release();
 
         for (typename __base::__map_pointer __i = __base::__map_.end();
                 __i != __base::__map_.begin();)
             __buf.push_front(*--__i);
         _VSTD::swap(__base::__map_.__first_, __buf.__first_);
         _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
         _VSTD::swap(__base::__map_.__end_, __buf.__end_);
         _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
     }
 }
 
 // Create back capacity for __n elements.
 // Strong guarantee.  Either do it or don't touch anything.
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
 {
     allocator_type& __a = __base::__alloc();
     size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
     // Number of unused blocks at front:
-    size_type __front_capacity = __front_spare() / __base::__block_size;
+    size_type __front_capacity = __front_spare() / __value_traits::__block_size;
     __front_capacity = _VSTD::min(__front_capacity, __nb);  // don't take more than you need
     __nb -= __front_capacity;  // number of blocks need to allocate
     // If __nb == 0, then we have sufficient capacity.
     if (__nb == 0)
     {
-        __base::__start_ -= __base::__block_size * __front_capacity;
+        __base::__start_ -= __value_traits::__block_size * __front_capacity;
         for (; __front_capacity > 0; --__front_capacity)
         {
             pointer __pt = __base::__map_.front();
             __base::__map_.pop_front();
             __base::__map_.push_back(__pt);
         }
     }
     // Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
     else if (__nb <= __base::__map_.capacity() - __base::__map_.size())
     {   // we can put the new buffers into the map, but don't shift things around
         // until all buffers are allocated.  If we throw, we don't need to fix
         // anything up (any added buffers are undetectible)
         for (; __nb > 0; --__nb)
         {
             if (__base::__map_.__back_spare() == 0)
                 break;
-            __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
+            __base::__map_.push_back(__alloc_traits::allocate(__a, __value_traits::__block_size));
         }
         for (; __nb > 0; --__nb, ++__front_capacity, __base::__start_ +=
-                                 __base::__block_size - (__base::__map_.size() == 1))
-            __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
+                                 __value_traits::__block_size - (__base::__map_.size() == 1))
+            __base::__map_.push_front(__alloc_traits::allocate(__a, __value_traits::__block_size));
         // Done allocating, reorder capacity
-        __base::__start_ -= __base::__block_size * __front_capacity;
+        __base::__start_ -= __value_traits::__block_size * __front_capacity;
         for (; __front_capacity > 0; --__front_capacity)
         {
             pointer __pt = __base::__map_.front();
             __base::__map_.pop_front();
             __base::__map_.push_back(__pt);
         }
     }
     // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
     else
     {
-        size_type __ds = __front_capacity * __base::__block_size;
+        size_type __ds = __front_capacity * __value_traits::__block_size;
         __split_buffer<pointer, typename __base::__pointer_allocator&>
             __buf(max<size_type>(2* __base::__map_.capacity(),
                                  __nb + __base::__map_.size()),
                   __base::__map_.size() - __front_capacity,
                   __base::__map_.__alloc());
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif  // _LIBCPP_NO_EXCEPTIONS
             for (; __nb > 0; --__nb)
-                __buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
+                __buf.push_back(__alloc_traits::allocate(__a, __value_traits::__block_size));
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
             for (typename __base::__map_pointer __i = __buf.begin();
                     __i != __buf.end(); ++__i)
-                __alloc_traits::deallocate(__a, *__i, __base::__block_size);
+                __alloc_traits::deallocate(__a, *__i, __value_traits::__block_size);
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
         for (; __front_capacity > 0; --__front_capacity)
         {
             __buf.push_back(__base::__map_.front());
             __base::__map_.pop_front();
         }

 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::pop_front()
 {
     allocator_type& __a = __base::__alloc();
     __alloc_traits::destroy(__a, __to_raw_pointer(*(__base::__map_.begin() +
-                                                    __base::__start_ / __base::__block_size) +
-                                                    __base::__start_ % __base::__block_size));
+                                                    __base::__start_ / __value_traits::__block_size) +
+                                                    __base::__start_ % __value_traits::__block_size));
     --__base::size();
-    if (++__base::__start_ >= 2 * __base::__block_size)
+    if (++__base::__start_ >= 2 * __value_traits::__block_size)
     {
-        __alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
+        __alloc_traits::deallocate(__a, __base::__map_.front(), __value_traits::__block_size);
         __base::__map_.pop_front();
-        __base::__start_ -= __base::__block_size;
+        __base::__start_ -= __value_traits::__block_size;
     }
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::pop_back()
 {
     allocator_type& __a = __base::__alloc();
     size_type __p = __base::size() + __base::__start_ - 1;
     __alloc_traits::destroy(__a, __to_raw_pointer(*(__base::__map_.begin() +
-                                                    __p / __base::__block_size) +
-                                                    __p % __base::__block_size));
+                                                    __p / __value_traits::__block_size) +
+                                                    __p % __value_traits::__block_size));
     --__base::size();
-    if (__back_spare() >= 2 * __base::__block_size)
+    if (__back_spare() >= 2 * __value_traits::__block_size)
     {
-        __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
+        __alloc_traits::deallocate(__a, __base::__map_.back(), __value_traits::__block_size);
         __base::__map_.pop_back();
     }
 }
 
 // move assign [__f, __l) to [__r, __r + (__l-__f)).
 // If __vt points into [__f, __l), then subtract (__f - __r) from __vt.
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l, iterator __r,
                                          const_pointer& __vt)
 {
     // as if
     //   for (; __f != __l; ++__f, ++__r)
     //       *__r = _VSTD::move(*__f);
     difference_type __n = __l - __f;
     while (__n > 0)
     {
         pointer __fb = __f.__ptr_;
-        pointer __fe = *__f.__m_iter_ + __base::__block_size;
+        pointer __fe = *__f.__m_iter_ + __value_traits::__block_size;
         difference_type __bs = __fe - __fb;
         if (__bs > __n)
         {
             __bs = __n;
             __fe = __fb + __bs;
         }
         if (__fb <= __vt && __vt < __fe)
             __vt = (const_iterator(static_cast<__map_const_pointer>(__f.__m_iter_), __vt) -= __f - __r).__ptr_;
deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
     allocator_type& __a = __base::__alloc();
     // as if
     //   for (; __f != __l; ++__r, ++__f, ++__base::size())
     //       __alloc_traits::construct(__a, _VSTD::addressof(*__r), _VSTD::move(*__f));
     difference_type __n = __l - __f;
     while (__n > 0)
     {
         pointer __fb = __f.__ptr_;
-        pointer __fe = *__f.__m_iter_ + __base::__block_size;
+        pointer __fe = *__f.__m_iter_ + __value_traits::__block_size;
         difference_type __bs = __fe - __fb;
         if (__bs > __n)
         {
             __bs = __n;
             __fe = __fb + __bs;
         }
         if (__fb <= __vt && __vt < __fe)
             __vt = (const_iterator(static_cast<__map_const_pointer>(__f.__m_iter_), __vt) += __r - __f).__ptr_;
deque<_Tp, _Allocator>::erase(const_iterator __f)
     iterator __p = __b + __pos;
     allocator_type& __a = __base::__alloc();
     if (__pos < (__base::size() - 1) / 2)
     {   // erase from front
         _VSTD::move_backward(__b, __p, _VSTD::next(__p));
         __alloc_traits::destroy(__a, _VSTD::addressof(*__b));
         --__base::size();
         ++__base::__start_;
-        if (__front_spare() >= 2 * __base::__block_size)
+        if (__front_spare() >= 2 * __value_traits::__block_size)
         {
-            __alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
+            __alloc_traits::deallocate(__a, __base::__map_.front(), __value_traits::__block_size);
             __base::__map_.pop_front();
-            __base::__start_ -= __base::__block_size;
+            __base::__start_ -= __value_traits::__block_size;
         }
     }
     else
     {   // erase from back
         iterator __i = _VSTD::move(_VSTD::next(__p), __base::end(), __p);
         __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
         --__base::size();
-        if (__back_spare() >= 2 * __base::__block_size)
+        if (__back_spare() >= 2 * __value_traits::__block_size)
         {
-            __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
+            __alloc_traits::deallocate(__a, __base::__map_.back(), __value_traits::__block_size);
             __base::__map_.pop_back();
         }
     }
     return __base::begin() + __pos;
 }
 
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
 {
     difference_type __n = __l - __f;
     iterator __b = __base::begin();
     difference_type __pos = __f - __b;
     iterator __p = __b + __pos;
     if (__n > 0)
     {
         allocator_type& __a = __base::__alloc();
         if (__pos < (__base::size() - __n) / 2)
         {   // erase from front
             iterator __i = _VSTD::move_backward(__b, __p, __p + __n);
             for (; __b != __i; ++__b)
                 __alloc_traits::destroy(__a, _VSTD::addressof(*__b));
             __base::size() -= __n;
             __base::__start_ += __n;
-            while (__front_spare() >= 2 * __base::__block_size)
+            while (__front_spare() >= 2 * __value_traits::__block_size)
             {
-                __alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
+                __alloc_traits::deallocate(__a, __base::__map_.front(), __value_traits::__block_size);
                 __base::__map_.pop_front();
-                __base::__start_ -= __base::__block_size;
+                __base::__start_ -= __value_traits::__block_size;
             }
         }
         else
         {   // erase from back
             iterator __i = _VSTD::move(__p + __n, __base::end(), __p);
             for (iterator __e = __base::end(); __i != __e; ++__i)
                 __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
             __base::size() -= __n;
-            while (__back_spare() >= 2 * __base::__block_size)
+            while (__back_spare() >= 2 * __value_traits::__block_size)
             {
-                __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
+                __alloc_traits::deallocate(__a, __base::__map_.back(), __value_traits::__block_size);
                 __base::__map_.pop_back();
             }
         }
     }
     return __base::begin() + __pos;
 }
 
 template <class _Tp, class _Allocator>
 void
 deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)
 {
     iterator __e = __base::end();
     difference_type __n = __e - __f;
     if (__n > 0)
     {
         allocator_type& __a = __base::__alloc();
         iterator __b = __base::begin();
         difference_type __pos = __f - __b;
         for (iterator __p = __b + __pos; __p != __e; ++__p)
             __alloc_traits::destroy(__a, _VSTD::addressof(*__p));
         __base::size() -= __n;
-        while (__back_spare() >= 2 * __base::__block_size)
+        while (__back_spare() >= 2 * __value_traits::__block_size)
         {
-            __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
+            __alloc_traits::deallocate(__a, __base::__map_.back(), __value_traits::__block_size);
             __base::__map_.pop_back();
         }
     }
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void

test/std/containers/sequences/deque/deque.cons/incomplete.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <deque>
+
+// deque()
+// deque::iterator()
+
+#include <deque>
+#include <cassert>
+
+struct A {
+  std::deque<A> d;
+  std::deque<A>::iterator it;
+  std::deque<A>::reverse_iterator it2;
+};
+
+int main()
+{
+  A a;
+  assert(a.d.size() == 0);
+  a.it = a.d.begin();
+  a.it2 = a.d.rend();
+}