[libcxx][modularisation] completes <memory> modularisation

[cjdb]

removes bogus header include

libcxx/include/__memory/temp_value.h

45

I believe this was indented in the old code. I've pulled it back to the start of the line in this patch, but no other source changes have been intentionally applied.

[• Quuxplusone]

LGTM % comments!

libcxx/include/__vector/construct.h

1

I'm not thrilled by the name of this file, although I can't come up with anything super better, so the current name is not unacceptable AFAIC. Possibly <__vector/construct_range.h> or <__vector/construct_helpers.h> would be better?

libcxx/include/memory

679

I think we still haven't made a consistent decision about whether <foo> should include all <__foo/bar.h> subheaders (like the module does), or just the "public-relevant" ones. However, for consistency with how this specific file currently includes <__memory/allocation_guard.h>, please #include all your new headers in here too.

...Except for <__vector/construct.h>, I suppose, since that's now part of <vector>. (It's basically as if we cut-and-pasted those components from here to there, in addition to the NFC parts of this patch. I think that's totally fine, because we're within our rights to shuffle around internal implementation details however often we like.)

704

This should move to <__memory/align.h>. It's just a one-liner, but it lets us make <memory> a true top-level header with no extraneous bits. (And no libc++ header will ever need to resort to #include <memory> for any reason except backward compatibility.)

(You'll also get rid of _LIBCPP_BEGIN_NAMESPACE_STD / _LIBCPP_END_NAMESPACE_STD at that point.)

[Mordante]

In general LGTM modulo some minor issues. I'll omit the libc++ approval for now, so we have another look after all issues have been addressed.

libcxx/include/__functional/builtin_new_allocator.h

18

libcxx/include/__memory/swap_allocator.h

18

libcxx/include/__vector/construct.h

1

I agree. Alternatively how about splitting this in multiple files?

[• Quuxplusone]

libcxx/include/__vector/construct.h

1

FWIW, I vote for not splitting this any further: all the functionality in here is tightly related. (But I see the counterargument, that the tight relation would still be implied by the fact that everything's under __vector/.)

[ldionne]

libcxx/include/__vector/construct.h

1

I'm fine with whatever name -- In the long term, I'd actually try to generalize those algorithms to make them usable not only in std::vector, but elsewhere too.

libcxx/include/memory

679

Yeah, let's include all of the __memory/foo.h headers since that's what we've been doing. Agreed on not including __vector/construct.h, since it is not part of __memory/.

[cjdb]

libcxx/include/memory

679

There's precedent where we don't do this from <functional>. I'm also not in favour of exporting implementation details, which is what this would enable (i.e. I'd prefer to go and make a CL that deletes the detail headers in other user-facing headers).

A lot of the stuff in this CL would be better off in some __container directory anyway, since they're common to containers headers, rather than stuff that genuinely is in <memory>.

[ldionne]

libcxx/include/memory

679

I'm fairly sure we had a discussion where we all agreed on including everything blindly, and I even think you were pushing on doing that -- unless my memory is failing me. Concretely, I think we might need to export implementation details if we want to be able to test them, since we're not allowed to include implementation detail headers. So say we wanted to test __memory/construct.h, right now we need to include <memory> and rely on the fact that it includes <__memory/construct.h>.

[cjdb]

libcxx/include/memory

679

Without context on the discussion (which I don't recall), I can't comment further.

I am against directly testing implementation details in general, and exposing them just for the sake of testing them is smelly.

[ldionne]

libcxx/include/memory

679

Without context on the discussion (which I don't recall), I can't comment further.

Agreed, but there's dozens of modularization patches with hundreds of comments on them in the aggregate, and Phab doesn't have a good search, so I won't bother. Let's pretend that the discussion never happened -- I don't think it has an impact on the point I'm trying to make.

Edit: I just found https://reviews.llvm.org/D107785#inline-1026088. It does provide some context but it doesn't involve you, so I was wrong, and it doesn't look like it was officially written in stone. However, see below.

I am against directly testing implementation details in general, and exposing them just for the sake of testing them is smelly.

Testing implementation details is often useful to increase our testing coverage when it's really difficult to black-box test something using only the standard API. We have some of it inside libcxx/test/libcxx, for example for testing helpers of <functional>. When that happens, we need a way to include the implementation detail header from a test file, and we can't use __memory/construct.h (for example) since that is a private submodule. IIRC, that is why we've been consistently including those implementation detail headers in the main header, so we should do it (if only) for consistency.

libcxx/include/CMakeLists.txt

 set(files
   __algorithm/adjacent_find.h
   __algorithm/all_of.h
   __algorithm/any_of.h
   __algorithm/binary_search.h
   __algorithm/clamp.h
   __algorithm/comp_ref_type.h
   __algorithm/comp.h
   __algorithm/copy_backward.h
   __algorithm/copy_if.h
   __algorithm/copy_n.h
   __algorithm/copy.h
   __algorithm/count_if.h
   __algorithm/count.h
+  __algorithm/destruct_n.h
   __algorithm/equal_range.h
   __algorithm/equal.h
   __algorithm/fill_n.h
   __algorithm/fill.h
   __algorithm/find_end.h
   __algorithm/find_first_of.h
   __algorithm/find_if_not.h
   __algorithm/find_if.h
set(files
   __functional_base
   __functional/binary_function.h
   __functional/binary_negate.h
   __functional/bind_back.h
   __functional/bind_front.h
   __functional/bind.h
   __functional/binder1st.h
   __functional/binder2nd.h
+  __functional/builtin_new_allocator.h
   __functional/compose.h
   __functional/default_searcher.h
   __functional/function.h
   __functional/hash.h
   __functional/identity.h
   __functional/invoke.h
   __functional/is_transparent.h
   __functional/mem_fn.h
set(files
   __memory/addressof.h
   __memory/allocation_guard.h
   __memory/allocator_arg_t.h
   __memory/allocator_traits.h
   __memory/allocator.h
   __memory/auto_ptr.h
   __memory/compressed_pair.h
   __memory/construct_at.h
+  __memory/is_allocator.h
+  __memory/noexcept_move_assign_container.h
   __memory/pointer_traits.h
   __memory/raw_storage_iterator.h
   __memory/shared_ptr.h
+  __memory/swap_allocator.h
+  __memory/temp_value.h
   __memory/temporary_buffer.h
   __memory/uninitialized_algorithms.h
   __memory/unique_ptr.h
   __memory/uses_allocator.h
   __mutex_base
   __numeric/accumulate.h
   __numeric/adjacent_difference.h
   __numeric/exclusive_scan.h
set(files
   __utility/move.h
   __utility/pair.h
   __utility/piecewise_construct.h
   __utility/priority_tag.h
   __utility/rel_ops.h
   __utility/swap.h
   __utility/to_underlying.h
   __variant/monostate.h
+  __vector/construct.h
   algorithm
   any
   array
   atomic
   barrier
   bit
   bitset
   cassert

libcxx/include/__algorithm/destruct_n.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_DESTRUCT_N_H
+#define _LIBCPP___ALGORITHM_DESTRUCT_N_H
+
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct __destruct_n
+{
+private:
+    size_t __size_;
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT
+        {for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();}
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT
+        {}
+
+    _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT
+        {++__size_;}
+    _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT
+        {}
+
+    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT
+        {__size_ = __s;}
+    _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT
+        {}
+public:
+    _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT
+        : __size_(__s) {}
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY void __incr() _NOEXCEPT
+        {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT
+        {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+
+    template <class _Tp>
+    _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT
+        {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ALGORITHM_DESTRUCT_N_H

libcxx/include/__algorithm/inplace_merge.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_INPLACE_MERGE_H
 #define _LIBCPP___ALGORITHM_INPLACE_MERGE_H
 
 #include <__config>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/comp.h>
+#include <__algorithm/destruct_n.h>
 #include <__algorithm/lower_bound.h>
 #include <__algorithm/min.h>
 #include <__algorithm/move.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/upper_bound.h>
 #include <__iterator/iterator_traits.h>
 #include <__utility/swap.h>
 #include <memory>

libcxx/include/__algorithm/sort.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_SORT_H
 #define _LIBCPP___ALGORITHM_SORT_H
 
 #include <__config>
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
+#include <__algorithm/destruct_n.h>
 #include <__algorithm/min_element.h>
 #include <__algorithm/partial_sort.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__utility/swap.h>
 #include <memory>
 
 #if defined(_LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY)
 #  include <__algorithm/shuffle.h>

libcxx/include/__algorithm/stable_partition.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_STABLE_PARTITION_H
 #define _LIBCPP___ALGORITHM_STABLE_PARTITION_H
 
 #include <__config>
+#include <__algorithm/destruct_n.h>
 #include <__algorithm/rotate.h>
 #include <__iterator/iterator_traits.h>
 #include <__utility/swap.h>
 #include <memory>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

libcxx/include/__algorithm/stable_sort.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ALGORITHM_STABLE_SORT_H
 #define _LIBCPP___ALGORITHM_STABLE_SORT_H
 
 #include <__config>
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
+#include <__algorithm/destruct_n.h>
 #include <__algorithm/inplace_merge.h>
 #include <__algorithm/sort.h>
 #include <__iterator/iterator_traits.h>
 #include <__utility/swap.h>
 #include <memory>
 #include <type_traits> // swap
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/__functional/builtin_new_allocator.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FUNCTIONAL_BUILTIN_NEW_ALLOCATOR_H
+#define _LIBCPP___FUNCTIONAL_BUILTIN_NEW_ALLOCATOR_H
+
+#include <__config>
+#include <__memory/unique_ptr.h>
+#include <cstddef>
+#include <new>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// __builtin_new_allocator -- A non-templated helper for allocating and
+// deallocating memory using __builtin_operator_new and
+// __builtin_operator_delete. It should be used in preference to
+// `std::allocator<T>` to avoid additional instantiations.
+struct __builtin_new_allocator {
+  struct __builtin_new_deleter {
+    typedef void* pointer_type;
+
+    _LIBCPP_CONSTEXPR explicit __builtin_new_deleter(size_t __size, size_t __align)
+        : __size_(__size), __align_(__align) {}
+
+    void operator()(void* p) const _NOEXCEPT {
+        _VSTD::__libcpp_deallocate(p, __size_, __align_);
+    }
+
+   private:
+    size_t __size_;
+    size_t __align_;
+  };
+
+  typedef unique_ptr<void, __builtin_new_deleter> __holder_t;
+
+  static __holder_t __allocate_bytes(size_t __s, size_t __align) {
+      return __holder_t(_VSTD::__libcpp_allocate(__s, __align),
+                     __builtin_new_deleter(__s, __align));
+  }
+
+  static void __deallocate_bytes(void* __p, size_t __s,
+                                 size_t __align) _NOEXCEPT {
+      _VSTD::__libcpp_deallocate(__p, __s, __align);
+  }
+
+  template <class _Tp>
+  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
+  static __holder_t __allocate_type(size_t __n) {
+      return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+  }
+
+  template <class _Tp>
+  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
+  static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
+      __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+  }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FUNCTIONAL_BUILTIN_NEW_ALLOCATOR_H

libcxx/include/__functional/function.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FUNCTIONAL_FUNCTION_H
 #define _LIBCPP___FUNCTIONAL_FUNCTION_H
 
 #include <__config>
 #include <__debug>
 #include <__functional/binary_function.h>
+#include <__functional/builtin_new_allocator.h>
 #include <__functional/invoke.h>
 #include <__functional/unary_function.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/shared_ptr.h>
 #include <exception>
 #include <memory> // TODO: replace with <__memory/__builtin_new_allocator.h>

libcxx/include/__hash_table

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP__HASH_TABLE
 #define _LIBCPP__HASH_TABLE
 
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
+#include <__memory/swap_allocator.h>
 #include <algorithm>
 #include <cmath>
 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <type_traits>
 #include <utility>
 

libcxx/include/__memory/is_allocator.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_IS_ALLOCATOR_H
+#define _LIBCPP___MEMORY_IS_ALLOCATOR_H
+
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <typename _Alloc, typename = void, typename = void>
+struct __is_allocator : false_type {};
+
+template <typename _Alloc>
+struct __is_allocator<_Alloc, typename __void_t<typename _Alloc::value_type>::type,
+                      typename __void_t<decltype(declval<_Alloc&>().allocate(size_t(0)))>::type > : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_IS_ALLOCATOR_H

libcxx/include/__memory/noexcept_move_assign_container.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H
+#define _LIBCPP___MEMORY_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H
+
+#include <__config>
+#include <__memory/allocator_traits.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <typename _Alloc, typename _Traits = allocator_traits<_Alloc> >
+struct __noexcept_move_assign_container
+    : public integral_constant<bool, _Traits::propagate_on_container_move_assignment::value
+#if _LIBCPP_STD_VER > 14
+                                         || _Traits::is_always_equal::value
+#else
+                                         && is_nothrow_move_assignable<_Alloc>::value
+#endif
+                               > {
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H

libcxx/include/__memory/swap_allocator.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_SWAP_ALLOCATOR_H
+#define _LIBCPP___MEMORY_SWAP_ALLOCATOR_H
+
+#include <__config>
+#include <__memory/allocator_traits.h>
+#include <__utility/swap.h>
+#include <type_traits>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// --- Helper for container swap --
+template <typename _Alloc>
+_LIBCPP_INLINE_VISIBILITY
+void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type)
+#if _LIBCPP_STD_VER >= 14
+    _NOEXCEPT
+#else
+    _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
+#endif
+{
+    using _VSTD::swap;
+    swap(__a1, __a2);
+}
+
+template <typename _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {}
+
+template <typename _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
+#if _LIBCPP_STD_VER >= 14
+    _NOEXCEPT
+#else
+    _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
+#endif
+{
+    _VSTD::__swap_allocator(__a1, __a2,
+      integral_constant<bool, allocator_traits<_Alloc>::propagate_on_container_swap::value>());
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_SWAP_ALLOCATOR_H

libcxx/include/__memory/temp_value.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_TEMP_VALUE_H
+#define _LIBCPP___MEMORY_TEMP_VALUE_H
+
+#include <__config>
+#include <__memory/allocator_traits.h>
+#include <__memory/addressof.h>
+#include <__utility/forward.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Alloc>
+struct __temp_value {
+    typedef allocator_traits<_Alloc> _Traits;
+
+    typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
+    _Alloc &__a;
+
+    _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); }
+    _Tp &   get() { return *__addr(); }
+
+    template<class... _Args>
+    _LIBCPP_NO_CFI
+    __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
+      _Traits::construct(__a, reinterpret_cast<_Tp*>(addressof(__v)),
+                         _VSTD::forward<_Args>(__args)...);
+    }
+
+    ~__temp_value() { _Traits::destroy(__a, __addr()); }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MEMORY_TEMP_VALUE_H

libcxx/include/__tree

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TREE
 #define _LIBCPP___TREE
 
 #include <__config>
+#include <__memory/swap_allocator.h>
 #include <__utility/forward.h>
 #include <algorithm>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <stdexcept>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/__vector/construct.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___VECTOR_CONSTRUCT_H
+#define _LIBCPP___VECTOR_CONSTRUCT_H
+
+#include <__memory/allocator_traits.h>
+#include <__memory/pointer_traits.h>
+#include <__utility/move.h>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Alloc, class _Ptr>
+_LIBCPP_INLINE_VISIBILITY
+void __construct_forward_with_exception_guarantees(_Alloc& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2) {
+    static_assert(__is_cpp17_move_insertable<_Alloc>::value,
+        "The specified type does not meet the requirements of Cpp17MoveInsertable");
+    typedef allocator_traits<_Alloc> _Traits;
+    for (; __begin1 != __end1; ++__begin1, (void)++__begin2) {
+        _Traits::construct(__a, _VSTD::__to_address(__begin2),
+#ifdef _LIBCPP_NO_EXCEPTIONS
+            _VSTD::move(*__begin1)
+#else
+            _VSTD::move_if_noexcept(*__begin1)
+#endif
+        );
+    }
+}
+
+template <class _Alloc, class _Tp, typename enable_if<
+    (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Tp*, _Tp>::value) &&
+    is_trivially_move_constructible<_Tp>::value
+>::type>
+_LIBCPP_INLINE_VISIBILITY
+void __construct_forward_with_exception_guarantees(_Alloc&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2) {
+    ptrdiff_t _Np = __end1 - __begin1;
+    if (_Np > 0) {
+        _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp));
+        __begin2 += _Np;
+    }
+}
+
+template <class _Alloc, class _Iter, class _Ptr>
+_LIBCPP_INLINE_VISIBILITY
+void __construct_range_forward(_Alloc& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2) {
+    typedef allocator_traits<_Alloc> _Traits;
+    for (; __begin1 != __end1; ++__begin1, (void) ++__begin2) {
+        _Traits::construct(__a, _VSTD::__to_address(__begin2), *__begin1);
+    }
+}
+
+template <class _Alloc, class _Source, class _Dest,
+          class _RawSource = typename remove_const<_Source>::type,
+          class _RawDest = typename remove_const<_Dest>::type,
+          class =
+    typename enable_if<
+        is_trivially_copy_constructible<_Dest>::value &&
+        is_same<_RawSource, _RawDest>::value &&
+        (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Dest*, _Source&>::value)
+    >::type>
+_LIBCPP_INLINE_VISIBILITY
+void __construct_range_forward(_Alloc&, _Source* __begin1, _Source* __end1, _Dest*& __begin2) {
+    ptrdiff_t _Np = __end1 - __begin1;
+    if (_Np > 0) {
+        _VSTD::memcpy(const_cast<_RawDest*>(__begin2), __begin1, _Np * sizeof(_Dest));
+        __begin2 += _Np;
+    }
+}
+
+template <class _Alloc, class _Ptr>
+_LIBCPP_INLINE_VISIBILITY
+void __construct_backward_with_exception_guarantees(_Alloc& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2) {
+    static_assert(__is_cpp17_move_insertable<_Alloc>::value,
+        "The specified type does not meet the requirements of Cpp17MoveInsertable");
+    typedef allocator_traits<_Alloc> _Traits;
+    while (__end1 != __begin1) {
+        _Traits::construct(__a, _VSTD::__to_address(__end2 - 1),
+#ifdef _LIBCPP_NO_EXCEPTIONS
+            _VSTD::move(*--__end1)
+#else
+            _VSTD::move_if_noexcept(*--__end1)
+#endif
+        );
+        --__end2;
+    }
+}
+
+template <class _Alloc, class _Tp, class = typename enable_if<
+    (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Tp*, _Tp>::value) &&
+    is_trivially_move_constructible<_Tp>::value
+>::type>
+_LIBCPP_INLINE_VISIBILITY
+void __construct_backward_with_exception_guarantees(_Alloc&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2) {
+    ptrdiff_t _Np = __end1 - __begin1;
+    __end2 -= _Np;
+    if (_Np > 0)
+        _VSTD::memcpy(static_cast<void*>(__end2), static_cast<void const*>(__begin1), _Np * sizeof(_Tp));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___VECTOR_CONSTRUCT_H

libcxx/include/deque

 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__iterator/iterator_traits.h>
+#include <__memory/is_allocator.h>
+#include <__memory/swap_allocator.h>
+#include <__memory/temp_value.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
 #include <algorithm>
 #include <compare>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
+#  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _Allocator> class __deque_base;
-template <class _Tp, class _Allocator = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS deque;
+template <class _Tp, class _Allocator>
+class __deque_base;
+template <class _Tp, class _Allocator = allocator<_Tp> >
+class _LIBCPP_TEMPLATE_VIS deque;
 
-template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
-          class _DiffType, _DiffType _BlockSize>
+template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize>
 class _LIBCPP_TEMPLATE_VIS __deque_iterator;
 
-template <class _RAIter,
-          class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
 __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-copy(_RAIter __f,
-     _RAIter __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+copy(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
      typename enable_if<__is_cpp17_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,
-     _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,
+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, _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);
 
-template <class _RAIter,
-          class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
 __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-copy_backward(_RAIter __f,
-              _RAIter __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+copy_backward(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
               typename enable_if<__is_cpp17_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,
-              _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,
+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, _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);
 
-template <class _RAIter,
-          class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
 __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-move(_RAIter __f,
-     _RAIter __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+move(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
      typename enable_if<__is_cpp17_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,
-     _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,
+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, _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);
 
-template <class _RAIter,
-          class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
 __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-move_backward(_RAIter __f,
-              _RAIter __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+move_backward(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
               typename enable_if<__is_cpp17_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,
-              _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,
+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, _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);
 
 template <class _ValueType, class _DiffType>
 struct __deque_block_size {
   static const _DiffType value = sizeof(_ValueType) < 256 ? 4096 / sizeof(_ValueType) : 16;
 };
 
-template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
-          class _DiffType, _DiffType _BS =
+template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType,
+          _DiffType _BS =
 #ifdef _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
               // Keep template parameter to avoid changing all template declarations thoughout
           // this file.
-                               0
 #else
-                               __deque_block_size<_ValueType, _DiffType>::value
 #endif
           >
-class _LIBCPP_TEMPLATE_VIS __deque_iterator
-{
-    typedef _MapPointer __map_iterator;
+class _LIBCPP_TEMPLATE_VIS __deque_iterator {
+
 public:
-    typedef _Pointer  pointer;
-    typedef _DiffType difference_type;
+  typedef _Pointer pointer;
+
 private:
-    __map_iterator __m_iter_;
-    pointer        __ptr_;
+  pointer __ptr_;
 
-    static const difference_type __block_size;
+
 public:
-    typedef _ValueType                  value_type;
-    typedef random_access_iterator_tag  iterator_category;
-    typedef _Reference                  reference;
+  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)
+      : __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, _BS>& __it,
                    typename enable_if<is_convertible<_Pp, pointer>::value>::type* = 0) _NOEXCEPT
-        : __m_iter_(__it.__m_iter_), __ptr_(__it.__ptr_) {}
+      : __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 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)
-        {
-            ++__m_iter_;
-            __ptr_ = *__m_iter_;
-        }
-        return *this;
-    }
+  _LIBCPP_INLINE_VISIBILITY __deque_iterator& operator++() {
+    if (++__ptr_ - *__m_iter_ == __block_size) {
 
-    _LIBCPP_INLINE_VISIBILITY __deque_iterator operator++(int)
-    {
-        __deque_iterator __tmp = *this;
-        ++(*this);
-        return __tmp;
-    }
+  _LIBCPP_INLINE_VISIBILITY __deque_iterator operator++(int) {
 
-    _LIBCPP_INLINE_VISIBILITY __deque_iterator& operator--()
-    {
-        if (__ptr_ == *__m_iter_)
-        {
-            --__m_iter_;
-            __ptr_ = *__m_iter_ + __block_size;
-        }
-        --__ptr_;
-        return *this;
-    }
+  _LIBCPP_INLINE_VISIBILITY __deque_iterator& operator--() {
+    if (__ptr_ == *__m_iter_) {
 
-    _LIBCPP_INLINE_VISIBILITY __deque_iterator operator--(int)
-    {
-        __deque_iterator __tmp = *this;
-        --(*this);
-        return __tmp;
-    }
+  _LIBCPP_INLINE_VISIBILITY __deque_iterator operator--(int) {
 
-    _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;
-            }
-            else // (__n < 0)
-            {
-                difference_type __z = __block_size - 1 - __n;
-                __m_iter_ -= __z / __block_size;
-                __ptr_ = *__m_iter_ + (__block_size - 1 - __z % __block_size);
-            }
-        }
-        return *this;
-    }
+  _LIBCPP_INLINE_VISIBILITY __deque_iterator& operator+=(difference_type __n) {
+    if (__n != 0) {
+      if (__n > 0) {
+      } else // (__n < 0)
 
-    _LIBCPP_INLINE_VISIBILITY __deque_iterator& operator-=(difference_type __n)
-    {
-        return *this += -__n;
-    }
+  _LIBCPP_INLINE_VISIBILITY __deque_iterator& operator-=(difference_type __n) { return *this += -__n; }
 
-    _LIBCPP_INLINE_VISIBILITY __deque_iterator operator+(difference_type __n) const
-    {
-        __deque_iterator __t(*this);
-        __t += __n;
-        return __t;
-    }
+  _LIBCPP_INLINE_VISIBILITY __deque_iterator operator+(difference_type __n) const {
 
-    _LIBCPP_INLINE_VISIBILITY __deque_iterator operator-(difference_type __n) const
-    {
-        __deque_iterator __t(*this);
-        __t -= __n;
-        return __t;
-    }
+  _LIBCPP_INLINE_VISIBILITY __deque_iterator operator-(difference_type __n) const {
 
-    _LIBCPP_INLINE_VISIBILITY
-    friend __deque_iterator operator+(difference_type __n, const __deque_iterator& __it)
-        {return __it + __n;}
+  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
-                 + (__x.__ptr_ - *__x.__m_iter_)
-                 - (__y.__ptr_ - *__y.__m_iter_);
-        return 0;
-    }
+  friend difference_type operator-(const __deque_iterator& __x, const __deque_iterator& __y) {
+      return (__x.__m_iter_ - __y.__m_iter_) * __block_size + (__x.__ptr_ - *__x.__m_iter_) -
+             (__y.__ptr_ - *__y.__m_iter_);
 
-    _LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const
-        {return *(*this + __n);}
+  _LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const { return *(*this + __n); }
+
+  _LIBCPP_INLINE_VISIBILITY friend bool operator==(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return __x.__ptr_ == __y.__ptr_;
+  }
+
+  _LIBCPP_INLINE_VISIBILITY friend bool operator!=(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return !(__x == __y);
+  }
+
+  _LIBCPP_INLINE_VISIBILITY friend bool operator<(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return __x.__m_iter_ < __y.__m_iter_ || (__x.__m_iter_ == __y.__m_iter_ && __x.__ptr_ < __y.__ptr_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY friend
-        bool operator==(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return __x.__ptr_ == __y.__ptr_;}
-
-    _LIBCPP_INLINE_VISIBILITY friend
-        bool operator!=(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return !(__x == __y);}
-
-    _LIBCPP_INLINE_VISIBILITY friend
-        bool operator<(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return __x.__m_iter_ < __y.__m_iter_ ||
-               (__x.__m_iter_ == __y.__m_iter_ && __x.__ptr_ < __y.__ptr_);}
-
-    _LIBCPP_INLINE_VISIBILITY friend
-        bool operator>(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return __y < __x;}
-
-    _LIBCPP_INLINE_VISIBILITY friend
-        bool operator<=(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return !(__y < __x);}
-
-    _LIBCPP_INLINE_VISIBILITY friend
-        bool operator>=(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return !(__x < __y);}
+  _LIBCPP_INLINE_VISIBILITY friend bool operator>(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return __y < __x;
+  }
+
+  _LIBCPP_INLINE_VISIBILITY friend bool operator<=(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return !(__y < __x);
+  }
+
+  _LIBCPP_INLINE_VISIBILITY friend bool operator>=(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return !(__x < __y);
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT
-        : __m_iter_(__m), __ptr_(__p) {}
+  _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_TEMPLATE_VIS deque;
-    template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp>
-        friend class _LIBCPP_TEMPLATE_VIS __deque_iterator;
+  template <class _Tp, class _Ap>
+  friend class __deque_base;
+  template <class _Tp, class _Ap>
+  friend class _LIBCPP_TEMPLATE_VIS deque;
 
-    template <class _RAIter,
-              class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-    friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-    copy(_RAIter __f,
-         _RAIter __l,
-         __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
-         typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*);
+  template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+  friend __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+  copy(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
 
-    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,
-         _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,
+  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, _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);
 
-    template <class _RAIter,
-              class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-    friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-    copy_backward(_RAIter __f,
-                  _RAIter __l,
-                  __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
-                  typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*);
+  template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+  friend __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+  copy_backward(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
 
-    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,
-                  _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);
+  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, _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,
 
-    template <class _RAIter,
-              class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-    friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-    move(_RAIter __f,
-         _RAIter __l,
-         __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
-         typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*);
+  template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+  friend __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+  move(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
 
-    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,
-         _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,
+  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, _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);
 
-    template <class _RAIter,
-              class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
-    friend
-    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-    move_backward(_RAIter __f,
-                  _RAIter __l,
-                  __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
-                  typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*);
+  template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+  friend __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
+  move_backward(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
 
-    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,
-                  _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);
+  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, _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,
 };
 
-template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
-          class _DiffType, _DiffType _BlockSize>
-const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer,
-                                 _DiffType, _BlockSize>::__block_size =
+template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize>
+const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer, _DiffType, _BlockSize>::__block_size =
     __deque_block_size<_ValueType, _DiffType>::value;
 
 // copy
 
-template <class _RAIter,
-          class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
 __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-copy(_RAIter __f,
-     _RAIter __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
-     typename enable_if<__is_cpp17_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;
-    const difference_type __block_size = __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::__block_size;
-    while (__f != __l)
-    {
-        pointer __rb = __r.__ptr_;
-        pointer __re = *__r.__m_iter_ + __block_size;
-        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;
+copy(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+     typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*) {
+  while (__f != __l) {
+    if (__n > __bs) {
 }
 
-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,
-     _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;
-    const difference_type __block_size = __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::__block_size;
-    difference_type __n = __l - __f;
-    while (__n > 0)
-    {
-        pointer __fb = __f.__ptr_;
-        pointer __fe = *__f.__m_iter_ + __block_size;
-        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 _OutputIterator>
+_OutputIterator copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
+                     __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l, _OutputIterator __r) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
-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,
+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)
-{
-    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;
-    const difference_type __block_size = __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::__block_size;
-    difference_type __n = __l - __f;
-    while (__n > 0)
-    {
-        pointer __fb = __f.__ptr_;
-        pointer __fe = *__f.__m_iter_ + __block_size;
-        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;
+                                                    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
 // copy_backward
 
-template <class _RAIter,
-          class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
 __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-copy_backward(_RAIter __f,
-              _RAIter __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
-              typename enable_if<__is_cpp17_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;
-    while (__f != __l)
-    {
-        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __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;
+copy_backward(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+              typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*) {
+  while (__f != __l) {
+    if (__n > __bs) {
 }
 
-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,
-              _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;
-    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 _OutputIterator>
+_OutputIterator copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
+                              __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l, _OutputIterator __r) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
-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,
+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)
-{
-    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;
-    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;
+                                                             __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
 // move
 
-template <class _RAIter,
-          class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
 __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-move(_RAIter __f,
-     _RAIter __l,
-     __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
-     typename enable_if<__is_cpp17_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;
-    const difference_type __block_size = __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::__block_size;
-    while (__f != __l)
-    {
-        pointer __rb = __r.__ptr_;
-        pointer __re = *__r.__m_iter_ + __block_size;
-        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;
+move(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+     typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*) {
+  while (__f != __l) {
+    if (__n > __bs) {
 }
 
-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,
-     _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;
-    const difference_type __block_size = __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::__block_size;
-    difference_type __n = __l - __f;
-    while (__n > 0)
-    {
-        pointer __fb = __f.__ptr_;
-        pointer __fe = *__f.__m_iter_ + __block_size;
-        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 _OutputIterator>
+_OutputIterator move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
+                     __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l, _OutputIterator __r) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
-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,
+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)
-{
-    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;
-    const difference_type __block_size = __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::__block_size;
-    difference_type __n = __l - __f;
-    while (__n > 0)
-    {
-        pointer __fb = __f.__ptr_;
-        pointer __fe = *__f.__m_iter_ + __block_size;
-        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;
+                                                    __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
 // move_backward
 
-template <class _RAIter,
-          class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
+template <class _RAIter, class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
 __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
-move_backward(_RAIter __f,
-              _RAIter __l,
-              __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
-              typename enable_if<__is_cpp17_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;
-    while (__f != __l)
-    {
-        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __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;
+move_backward(_RAIter __f, _RAIter __l, __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
+              typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*) {
+  while (__f != __l) {
+    if (__n > __bs) {
 }
 
-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,
-              _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;
-    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 _OutputIterator>
+_OutputIterator move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
+                              __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l, _OutputIterator __r) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
-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,
+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)
-{
-    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;
-    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;
+                                                             __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
 template <class _Tp, class _Allocator>
-class __deque_base
-{
-    __deque_base(const __deque_base& __c);
-    __deque_base& operator=(const __deque_base& __c);
+class __deque_base {
+
 public:
-    typedef _Allocator                                allocator_type;
-    typedef allocator_traits<allocator_type>          __alloc_traits;
-    typedef typename __alloc_traits::size_type        size_type;
+  typedef _Allocator allocator_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
+  typedef typename __alloc_traits::size_type size_type;
 
-    typedef _Tp                                       value_type;
-    typedef value_type&                               reference;
-    typedef const value_type&                         const_reference;
-    typedef typename __alloc_traits::difference_type  difference_type;
-    typedef typename __alloc_traits::pointer          pointer;
-    typedef typename __alloc_traits::const_pointer    const_pointer;
+  typedef _Tp value_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  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;
 
-    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 allocator_traits<__pointer_allocator> __map_traits;
+  typedef typename __map_traits::pointer __map_pointer;
 
-    typedef __deque_iterator<value_type, pointer, reference, __map_pointer,
-                             difference_type>    iterator;
-    typedef __deque_iterator<value_type, const_pointer, const_reference, __map_const_pointer,
-                             difference_type>    const_iterator;
+  typedef __deque_iterator<value_type, pointer, reference, __map_pointer, difference_type> iterator;
+  typedef __deque_iterator<value_type, const_pointer, const_reference, __map_const_pointer, difference_type>
+      const_iterator;
 
-    struct __deque_block_range {
-      explicit __deque_block_range(pointer __b, pointer __e) _NOEXCEPT : __begin_(__b), __end_(__e) {}
-      const pointer __begin_;
-      const pointer __end_;
-    };
 
-    struct __deque_range {
-      iterator __pos_;
-      const iterator __end_;
 
-      __deque_range(iterator __pos, iterator __e) _NOEXCEPT
-        : __pos_(__pos), __end_(__e) {}
+    __deque_range(iterator __pos, iterator __e) _NOEXCEPT : __pos_(__pos), __end_(__e) {}
 
-      explicit operator bool() const _NOEXCEPT {
-        return __pos_ != __end_;
-      }
+    explicit operator bool() const _NOEXCEPT { return __pos_ != __end_; }
 
-      __deque_range begin() const {
-        return *this;
-      }
+    __deque_range begin() const { return *this; }
 
-      __deque_range end() const {
-        return __deque_range(__end_, __end_);
-      }
-      __deque_block_range operator*() const _NOEXCEPT {
-         if (__pos_.__m_iter_ == __end_.__m_iter_) {
-          return __deque_block_range(__pos_.__ptr_, __end_.__ptr_);
-        }
-        return __deque_block_range(__pos_.__ptr_, *__pos_.__m_iter_ + __block_size);
-      }
+    __deque_range end() const { return __deque_range(__end_, __end_); }
 
-      __deque_range& operator++() _NOEXCEPT {
-        if (__pos_.__m_iter_ == __end_.__m_iter_) {
-          __pos_ = __end_;
-        } else {
-          ++__pos_.__m_iter_;
-          __pos_.__ptr_ = *__pos_.__m_iter_;
-        }
-        return *this;
-      }
 
-
-      friend bool operator==(__deque_range const& __lhs, __deque_range const& __rhs) {
-        return __lhs.__pos_ == __rhs.__pos_;
-      }
-      friend bool operator!=(__deque_range const& __lhs, __deque_range const& __rhs) {
-        return !(__lhs == __rhs);
-      }
-    };
+    friend bool operator!=(__deque_range const& __lhs, __deque_range const& __rhs) { return !(__lhs == __rhs); }
 
-
-
-    struct _ConstructTransaction {
-      _ConstructTransaction(__deque_base* __db, __deque_block_range& __r)
         : __pos_(__r.__begin_), __end_(__r.__end_), __begin_(__r.__begin_), __base_(__db) {}
 
-
-      ~_ConstructTransaction() {
-        __base_->size() += (__pos_ - __begin_);
-      }
+    ~_ConstructTransaction() { __base_->size() += (__pos_ - __begin_); }
 
-      pointer __pos_;
-      const pointer __end_;
-    private:
-      const pointer __begin_;
-      __deque_base * const __base_;
-    };
+
+    __deque_base* const __base_;
 
 protected:
-    __map __map_;
-    size_type __start_;
-    __compressed_pair<size_type, allocator_type> __size_;
 
-    iterator       begin() _NOEXCEPT;
-    const_iterator begin() const _NOEXCEPT;
-    iterator       end() _NOEXCEPT;
-    const_iterator end() const _NOEXCEPT;
+  iterator begin() _NOEXCEPT;
+  iterator end() _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY size_type&            size()          {return __size_.first();}
-    _LIBCPP_INLINE_VISIBILITY
-    const size_type& size() const _NOEXCEPT {return __size_.first();}
-    _LIBCPP_INLINE_VISIBILITY allocator_type&       __alloc()       {return __size_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const allocator_type& __alloc() const _NOEXCEPT {return __size_.second();}
+  _LIBCPP_INLINE_VISIBILITY size_type& size() { return __size_.first(); }
+  const size_type& size() const _NOEXCEPT { return __size_.first(); }
+  _LIBCPP_INLINE_VISIBILITY allocator_type& __alloc() { return __size_.second(); }
+  const allocator_type& __alloc() const _NOEXCEPT { return __size_.second(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __deque_base()
-        _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __deque_base(const allocator_type& __a);
+  __deque_base() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
+
 public:
-    ~__deque_base();
 
 #ifndef _LIBCPP_CXX03_LANG
-    __deque_base(__deque_base&& __c)
-        _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
-    __deque_base(__deque_base&& __c, const allocator_type& __a);
+  __deque_base(__deque_base&& __c) _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
 #endif // _LIBCPP_CXX03_LANG
 
-    void swap(__deque_base& __c)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT;
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<allocator_type>::value);
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<allocator_type>::value);
 #endif
 protected:
-    void clear() _NOEXCEPT;
 
-    bool __invariants() const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign(__deque_base& __c)
-        _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
-                   is_nothrow_move_assignable<allocator_type>::value)
-    {
-        __map_ = _VSTD::move(__c.__map_);
-        __start_ = __c.__start_;
-        size() = __c.size();
-        __move_assign_alloc(__c);
-        __c.__start_ = __c.size() = 0;
-    }
+  void __move_assign(__deque_base& __c) _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value&&
+                                                       is_nothrow_move_assignable<allocator_type>::value) {
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__deque_base& __c)
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_move_assignment::value ||
-                   is_nothrow_move_assignable<allocator_type>::value)
-        {__move_assign_alloc(__c, integral_constant<bool,
-                      __alloc_traits::propagate_on_container_move_assignment::value>());}
+                 is_nothrow_move_assignable<allocator_type>::value) {
+    __move_assign_alloc(__c, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__deque_base& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-        {
-            __alloc() = _VSTD::move(__c.__alloc());
-        }
+  void __move_assign_alloc(__deque_base& __c, true_type) _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__deque_base&, false_type) _NOEXCEPT
-        {}
+  void __move_assign_alloc(__deque_base&, false_type) _NOEXCEPT {}
 };
 
 template <class _Tp, class _Allocator>
-const typename __deque_base<_Tp, _Allocator>::difference_type
-    __deque_base<_Tp, _Allocator>::__block_size =
-        __deque_block_size<value_type, difference_type>::value;
+const typename __deque_base<_Tp, _Allocator>::difference_type __deque_base<_Tp, _Allocator>::__block_size =
 
 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)
-        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)
-            return false;
-        if (__start_ >= __map_.size() * __block_size - size())
-            return false;
-    }
-    else
-    {
-        if (size() != 0)
-            return false;
-        if (__start_ != 0)
-            return false;
-    }
-    return true;
+bool __deque_base<_Tp, _Allocator>::__invariants() const {
+  for (typename __map::const_iterator __i = __map_.begin(), __e = __map_.end(); __i != __e; ++__i)
+  if (__map_.size() != 0) {
+  } else {
 }
 
 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);
+typename __deque_base<_Tp, _Allocator>::iterator __deque_base<_Tp, _Allocator>::begin() _NOEXCEPT {
 }
 
 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);
+typename __deque_base<_Tp, _Allocator>::const_iterator __deque_base<_Tp, _Allocator>::begin() const _NOEXCEPT {
 }
 
 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);
+typename __deque_base<_Tp, _Allocator>::iterator __deque_base<_Tp, _Allocator>::end() _NOEXCEPT {
 }
 
 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);
+typename __deque_base<_Tp, _Allocator>::const_iterator __deque_base<_Tp, _Allocator>::end() const _NOEXCEPT {
 }
 
 template <class _Tp, class _Allocator>
-inline
-__deque_base<_Tp, _Allocator>::__deque_base()
-    _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
+inline __deque_base<_Tp, _Allocator>::__deque_base() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __start_(0), __size_(0, __default_init_tag()) {}
 
 template <class _Tp, class _Allocator>
-inline
-__deque_base<_Tp, _Allocator>::__deque_base(const allocator_type& __a)
+inline __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);
+__deque_base<_Tp, _Allocator>::~__deque_base() {
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 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_)),
-      __start_(_VSTD::move(__c.__start_)),
-      __size_(_VSTD::move(__c.__size_))
-{
-    __c.__start_ = 0;
-    __c.size() = 0;
+    : __map_(_VSTD::move(__c.__map_)), __start_(_VSTD::move(__c.__start_)), __size_(_VSTD::move(__c.__size_)) {
 }
 
 template <class _Tp, class _Allocator>
 __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c, const allocator_type& __a)
-    : __map_(_VSTD::move(__c.__map_), __pointer_allocator(__a)),
-      __start_(_VSTD::move(__c.__start_)),
-      __size_(_VSTD::move(__c.size()), __a)
-{
-    if (__a == __c.__alloc())
-    {
-        __c.__start_ = 0;
-        __c.size() = 0;
-    }
-    else
-    {
-        __map_.clear();
-        __start_ = 0;
-        size() = 0;
-    }
+    : __map_(_VSTD::move(__c.__map_), __pointer_allocator(__a)), __start_(_VSTD::move(__c.__start_)),
+      __size_(_VSTD::move(__c.size()), __a) {
+  if (__a == __c.__alloc()) {
+  } else {
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
-void
-__deque_base<_Tp, _Allocator>::swap(__deque_base& __c)
+void __deque_base<_Tp, _Allocator>::swap(__deque_base& __c)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<allocator_type>::value)
+    _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<allocator_type>::value)
 #endif
 {
-    __map_.swap(__c.__map_);
-    _VSTD::swap(__start_, __c.__start_);
-    _VSTD::swap(size(), __c.size());
-    _VSTD::__swap_allocator(__alloc(), __c.__alloc());
 }
 
 template <class _Tp, class _Allocator>
-void
-__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);
-        __map_.pop_front();
-    }
-    switch (__map_.size())
-    {
-    case 1:
-        __start_ = __block_size / 2;
-        break;
-    case 2:
-        __start_ = __block_size;
-        break;
-    }
+void __deque_base<_Tp, _Allocator>::clear() _NOEXCEPT {
+  while (__map_.size() > 2) {
+  switch (__map_.size()) {
 }
 
 template <class _Tp, class _Allocator /*= allocator<_Tp>*/>
-class _LIBCPP_TEMPLATE_VIS deque
-    : private __deque_base<_Tp, _Allocator>
-{
+class _LIBCPP_TEMPLATE_VIS deque : private __deque_base<_Tp, _Allocator> {
 public:
-    // types:
 
-    typedef _Tp value_type;
-    typedef _Allocator allocator_type;
 
-    static_assert((is_same<typename allocator_type::value_type, value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
 
-    typedef __deque_base<value_type, allocator_type>      __base;
+  typedef __deque_base<value_type, allocator_type> __base;
 
-    typedef typename __base::__alloc_traits               __alloc_traits;
-    typedef typename __base::reference                    reference;
-    typedef typename __base::const_reference              const_reference;
-    typedef typename __base::iterator                     iterator;
-    typedef typename __base::const_iterator               const_iterator;
-    typedef typename __base::size_type                    size_type;
-    typedef typename __base::difference_type              difference_type;
+  typedef typename __base::__alloc_traits __alloc_traits;
+  typedef typename __base::reference reference;
+  typedef typename __base::const_reference const_reference;
+  typedef typename __base::iterator iterator;
+  typedef typename __base::const_iterator const_iterator;
+  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;
+  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;
 
-    using typename __base::__deque_range;
-    using typename __base::__deque_block_range;
-    using typename __base::_ConstructTransaction;
+  using typename __base::__deque_range;
 
-    // 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);
+  deque() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) {}
 #if _LIBCPP_STD_VER > 11
-    explicit deque(size_type __n, const _Allocator& __a);
 #endif
-    deque(size_type __n, const value_type& __v);
 
-    template <class = __enable_if_t<__is_allocator<_Allocator>::value> >
-    deque(size_type __n, const value_type& __v, const allocator_type& __a) : __base(__a)
-    {
-        if (__n > 0)
-            __append(__n, __v);
-    }
+  deque(size_type __n, const value_type& __v, const allocator_type& __a) : __base(__a) {
 
-    template <class _InputIter>
-        deque(_InputIter __f, _InputIter __l,
-              typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = 0);
-    template <class _InputIter>
-        deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
-              typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = 0);
-    deque(const deque& __c);
-    deque(const deque& __c, const __identity_t<allocator_type>& __a);
+  deque(_InputIter __f, _InputIter __l, typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type* = 0);
 
-    deque& operator=(const deque& __c);
 
 #ifndef _LIBCPP_CXX03_LANG
-    deque(initializer_list<value_type> __il);
-    deque(initializer_list<value_type> __il, const allocator_type& __a);
 
-    _LIBCPP_INLINE_VISIBILITY
-    deque& operator=(initializer_list<value_type> __il) {assign(__il); return *this;}
+  deque& operator=(initializer_list<value_type> __il) {
+    assign(__il);
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    deque(deque&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    deque(deque&& __c, const __identity_t<allocator_type>& __a);
-    _LIBCPP_INLINE_VISIBILITY
-    deque& operator=(deque&& __c)
-        _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
+  deque& operator=(deque&& __c) _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value&&
                                                is_nothrow_move_assignable<allocator_type>::value);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void assign(initializer_list<value_type> __il) {assign(__il.begin(), __il.end());}
+  void assign(initializer_list<value_type> __il) { assign(__il.begin(), __il.end()); }
 #endif // _LIBCPP_CXX03_LANG
 
-    template <class _InputIter>
-        void assign(_InputIter __f, _InputIter __l,
-                    typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
-                                      !__is_cpp17_random_access_iterator<_InputIter>::value>::type* = 0);
-    template <class _RAIter>
-        void assign(_RAIter __f, _RAIter __l,
-                    typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type* = 0);
-    void assign(size_type __n, const value_type& __v);
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT;
 
-    // iterators:
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT       {return __base::begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return __base::begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT         {return __base::end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()   const _NOEXCEPT {return __base::end();}
+  iterator begin() _NOEXCEPT { return __base::begin(); }
+  const_iterator begin() const _NOEXCEPT { return __base::begin(); }
+  iterator end() _NOEXCEPT { return __base::end(); }
+  const_iterator end() const _NOEXCEPT { return __base::end(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    reverse_iterator       rbegin() _NOEXCEPT
-        {return       reverse_iterator(__base::end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(__base::end());}
-    _LIBCPP_INLINE_VISIBILITY
-    reverse_iterator       rend() _NOEXCEPT
-        {return       reverse_iterator(__base::begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend()   const _NOEXCEPT
-        {return const_reverse_iterator(__base::begin());}
+  reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(__base::end()); }
+  const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(__base::end()); }
+  reverse_iterator rend() _NOEXCEPT { return reverse_iterator(__base::begin()); }
+  const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(__base::begin()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator         cbegin()  const _NOEXCEPT
-        {return __base::begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator         cend()    const _NOEXCEPT
-        {return __base::end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT
-        {return const_reverse_iterator(__base::end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend()   const _NOEXCEPT
-        {return const_reverse_iterator(__base::begin());}
+  const_iterator cbegin() const _NOEXCEPT { return __base::begin(); }
+  const_iterator cend() const _NOEXCEPT { return __base::end(); }
+  const_reverse_iterator crbegin() const _NOEXCEPT { return const_reverse_iterator(__base::end()); }
+  const_reverse_iterator crend() const _NOEXCEPT { return const_reverse_iterator(__base::begin()); }
 
-    // capacity:
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT {return __base::size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT
-        {return _VSTD::min<size_type>(
-            __alloc_traits::max_size(__base::__alloc()),
-            numeric_limits<difference_type>::max());}
-    void resize(size_type __n);
-    void resize(size_type __n, const value_type& __v);
-    void shrink_to_fit() _NOEXCEPT;
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return __base::size() == 0;}
+  size_type size() const _NOEXCEPT { return __base::size(); }
+  size_type max_size() const _NOEXCEPT {
+    return _VSTD::min<size_type>(__alloc_traits::max_size(__base::__alloc()), numeric_limits<difference_type>::max());
+  }
+  _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT { return __base::size() == 0; }
 
-    // element access:
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator[](size_type __i) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference operator[](size_type __i) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    reference at(size_type __i);
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference at(size_type __i) const;
-    _LIBCPP_INLINE_VISIBILITY
-    reference front() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference front() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    reference back() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference back() const _NOEXCEPT;
 
-    // 23.2.2.3 modifiers:
-    void push_front(const value_type& __v);
-    void push_back(const value_type& __v);
 #ifndef _LIBCPP_CXX03_LANG
-#if _LIBCPP_STD_VER > 14
-    template <class... _Args> reference emplace_front(_Args&&... __args);
-    template <class... _Args> reference emplace_back (_Args&&... __args);
-#else
-    template <class... _Args> void      emplace_front(_Args&&... __args);
-    template <class... _Args> void      emplace_back (_Args&&... __args);
-#endif
-    template <class... _Args> iterator emplace(const_iterator __p, _Args&&... __args);
+#  if _LIBCPP_STD_VER > 14
+  template <class... _Args>
+  reference emplace_front(_Args&&... __args);
+  template <class... _Args>
+  reference emplace_back(_Args&&... __args);
+#  else
+  template <class... _Args>
+  void emplace_front(_Args&&... __args);
+  template <class... _Args>
+  void emplace_back(_Args&&... __args);
+#  endif
+  template <class... _Args>
+  iterator emplace(const_iterator __p, _Args&&... __args);
 
-    void push_front(value_type&& __v);
-    void push_back(value_type&& __v);
-    iterator insert(const_iterator __p, value_type&& __v);
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, initializer_list<value_type> __il)
-        {return insert(__p, __il.begin(), __il.end());}
+  iterator insert(const_iterator __p, initializer_list<value_type> __il) {
+    return insert(__p, __il.begin(), __il.end());
+  }
 #endif // _LIBCPP_CXX03_LANG
-    iterator insert(const_iterator __p, const value_type& __v);
-    iterator insert(const_iterator __p, size_type __n, const value_type& __v);
-    template <class _InputIter>
-        iterator insert(const_iterator __p, _InputIter __f, _InputIter __l,
-                         typename enable_if<__is_cpp17_input_iterator<_InputIter>::value
-                                         &&!__is_cpp17_forward_iterator<_InputIter>::value>::type* = 0);
-    template <class _ForwardIterator>
-        iterator insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
-                               typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value
-                                         &&!__is_cpp17_bidirectional_iterator<_ForwardIterator>::value>::type* = 0);
-    template <class _BiIter>
-        iterator insert(const_iterator __p, _BiIter __f, _BiIter __l,
-                         typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type* = 0);
+                  typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
+                                     !__is_cpp17_forward_iterator<_InputIter>::value>::type* = 0);
+                  typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
+                                     !__is_cpp17_bidirectional_iterator<_ForwardIterator>::value>::type* = 0);
 
-    void pop_front();
-    void pop_back();
-    iterator erase(const_iterator __p);
-    iterator erase(const_iterator __f, const_iterator __l);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(deque& __c)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT;
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                   __is_nothrow_swappable<allocator_type>::value);
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<allocator_type>::value);
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool __invariants() const {return __base::__invariants();}
+  bool __invariants() const { return __base::__invariants(); }
 
-    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);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    size_type __capacity() const
-    {
-        return __base::__map_.size() == 0 ? 0 : __base::__map_.size() * __base::__block_size - 1;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    size_type __block_count() const
-    {
-        return __base::__map_.size();
-    }
+  static size_type __recommend_blocks(size_type __n) {
+  size_type __capacity() const {
+  size_type __block_count() const { return __base::__map_.size(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type __front_spare() const
-    {
-        return __base::__start_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    size_type __front_spare_blocks() const {
-      return __front_spare() / __base::__block_size;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    size_type __back_spare() const
-    {
-        return __capacity() - (__base::__start_ + __base::size());
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    size_type __back_spare_blocks() const {
-      return __back_spare() / __base::__block_size;
-    }
+  size_type __front_spare() const { return __base::__start_; }
+  size_type __front_spare_blocks() const { return __front_spare() / __base::__block_size; }
+  size_type __back_spare() const { return __capacity() - (__base::__start_ + __base::size()); }
+  size_type __back_spare_blocks() const { return __back_spare() / __base::__block_size; }
 
- private:
-    _LIBCPP_INLINE_VISIBILITY
-    bool __maybe_remove_front_spare(bool __keep_one = true) {
-      if (__front_spare_blocks() >= 2 || (!__keep_one && __front_spare_blocks())) {
-        __alloc_traits::deallocate(__base::__alloc(), __base::__map_.front(),
-                                   __base::__block_size);
-        __base::__map_.pop_front();
-        __base::__start_ -= __base::__block_size;
-        return true;
-      }
-      return false;
-    }
+      __alloc_traits::deallocate(__base::__alloc(), __base::__map_.front(), __base::__block_size);
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool __maybe_remove_back_spare(bool __keep_one = true) {
-      if (__back_spare_blocks() >= 2 || (!__keep_one && __back_spare_blocks())) {
-        __alloc_traits::deallocate(__base::__alloc(), __base::__map_.back(),
-                                   __base::__block_size);
-        __base::__map_.pop_back();
-        return true;
-      }
-      return false;
-    }
+      __alloc_traits::deallocate(__base::__alloc(), __base::__map_.back(), __base::__block_size);
 
-    template <class _InpIter>
-        void __append(_InpIter __f, _InpIter __l,
-                 typename enable_if<__is_cpp17_input_iterator<_InpIter>::value &&
                                    !__is_cpp17_forward_iterator<_InpIter>::value>::type* = 0);
-    template <class _ForIter>
-        void __append(_ForIter __f, _ForIter __l,
-                      typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type* = 0);
-    void __append(size_type __n);
-    void __append(size_type __n, const value_type& __v);
-    void __erase_to_end(const_iterator __f);
-    void __add_front_capacity();
-    void __add_front_capacity(size_type __n);
-    void __add_back_capacity();
-    void __add_back_capacity(size_type __n);
-    iterator __move_and_check(iterator __f, iterator __l, iterator __r,
-                              const_pointer& __vt);
-    iterator __move_backward_and_check(iterator __f, iterator __l, iterator __r,
-                                       const_pointer& __vt);
-    void __move_construct_and_check(iterator __f, iterator __l,
-                                    iterator __r, const_pointer& __vt);
-    void __move_construct_backward_and_check(iterator __f, iterator __l,
-                                             iterator __r, const_pointer& __vt);
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const deque& __c)
-        {__copy_assign_alloc(__c, integral_constant<bool,
-                      __alloc_traits::propagate_on_container_copy_assignment::value>());}
+  iterator __move_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt);
+  iterator __move_backward_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt);
+  void __move_construct_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt);
+  void __move_construct_backward_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const deque& __c, true_type)
-        {
-            if (__base::__alloc() != __c.__alloc())
-            {
-                clear();
-                shrink_to_fit();
-            }
-            __base::__alloc() = __c.__alloc();
-            __base::__map_.__alloc() = __c.__map_.__alloc();
-        }
+  void __copy_assign_alloc(const deque& __c) {
+    __copy_assign_alloc(__c, integral_constant<bool, __alloc_traits::propagate_on_container_copy_assignment::value>());
+  }
+
+  _LIBCPP_INLINE_VISIBILITY
+  void __copy_assign_alloc(const deque& __c, true_type) {
+    if (__base::__alloc() != __c.__alloc()) {
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const deque&, false_type)
-        {}
+  void __copy_assign_alloc(const deque&, false_type) {}
 
-    void __move_assign(deque& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
-    void __move_assign(deque& __c, false_type);
+  void __move_assign(deque& __c, true_type) _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Alloc = allocator<__iter_value_type<_InputIterator>>,
+template <class _InputIterator, class _Alloc = allocator<__iter_value_type<_InputIterator>>,
           class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Alloc>::value>
-         >
-deque(_InputIterator, _InputIterator)
-  -> deque<__iter_value_type<_InputIterator>, _Alloc>;
+          class = enable_if_t<__is_allocator<_Alloc>::value> >
+deque(_InputIterator, _InputIterator) -> deque<__iter_value_type<_InputIterator>, _Alloc>;
 
-template<class _InputIterator,
-         class _Alloc,
-         class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Alloc>::value>
-         >
-deque(_InputIterator, _InputIterator, _Alloc)
-  -> deque<__iter_value_type<_InputIterator>, _Alloc>;
+template <class _InputIterator, class _Alloc, class = enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Alloc>::value> >
+deque(_InputIterator, _InputIterator, _Alloc) -> deque<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>::deque(size_type __n)
-{
-    if (__n > 0)
-        __append(__n);
+deque<_Tp, _Allocator>::deque(size_type __n) {
 }
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>::deque(size_type __n, const _Allocator& __a)
-    : __base(__a)
-{
-    if (__n > 0)
-        __append(__n);
+deque<_Tp, _Allocator>::deque(size_type __n, const _Allocator& __a) : __base(__a) {
 }
 #endif
 
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v)
-{
-    if (__n > 0)
-        __append(__n, __v);
+deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v) {
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l,
-              typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type*)
-{
-    __append(__f, __l);
+                              typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type*) {
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
                               typename enable_if<__is_cpp17_input_iterator<_InputIter>::value>::type*)
-    : __base(__a)
-{
-    __append(__f, __l);
+    : __base(__a) {
 }
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(const deque& __c)
-    : __base(__alloc_traits::select_on_container_copy_construction(__c.__alloc()))
-{
-    __append(__c.begin(), __c.end());
+    : __base(__alloc_traits::select_on_container_copy_construction(__c.__alloc())) {
 }
 
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>::deque(const deque& __c, const __identity_t<allocator_type>& __a)
-    : __base(__a)
-{
-    __append(__c.begin(), __c.end());
+deque<_Tp, _Allocator>::deque(const deque& __c, const __identity_t<allocator_type>& __a) : __base(__a) {
 }
 
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>&
-deque<_Tp, _Allocator>::operator=(const deque& __c)
-{
-    if (this != _VSTD::addressof(__c))
-    {
-        __copy_assign_alloc(__c);
-        assign(__c.begin(), __c.end());
-    }
-    return *this;
+deque<_Tp, _Allocator>& deque<_Tp, _Allocator>::operator=(const deque& __c) {
+  if (this != _VSTD::addressof(__c)) {
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il)
-{
-    __append(__il.begin(), __il.end());
+deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il) {
 }
 
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il, const allocator_type& __a)
-    : __base(__a)
-{
-    __append(__il.begin(), __il.end());
+deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il, const allocator_type& __a) : __base(__a) {
 }
 
 template <class _Tp, class _Allocator>
-inline
-deque<_Tp, _Allocator>::deque(deque&& __c)
-    _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
-    : __base(_VSTD::move(__c))
-{
-}
+inline deque<_Tp, _Allocator>::deque(deque&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
+    : __base(_VSTD::move(__c)) {}
 
 template <class _Tp, class _Allocator>
-inline
-deque<_Tp, _Allocator>::deque(deque&& __c, const __identity_t<allocator_type>& __a)
-    : __base(_VSTD::move(__c), __a)
-{
-    if (__a != __c.__alloc())
-    {
-        typedef move_iterator<iterator> _Ip;
-        assign(_Ip(__c.begin()), _Ip(__c.end()));
-    }
+inline deque<_Tp, _Allocator>::deque(deque&& __c, const __identity_t<allocator_type>& __a)
+    : __base(_VSTD::move(__c), __a) {
+  if (__a != __c.__alloc()) {
 }
 
 template <class _Tp, class _Allocator>
-inline
-deque<_Tp, _Allocator>&
-deque<_Tp, _Allocator>::operator=(deque&& __c)
-        _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
-                   is_nothrow_move_assignable<allocator_type>::value)
-{
-    __move_assign(__c, integral_constant<bool,
-          __alloc_traits::propagate_on_container_move_assignment::value>());
-    return *this;
+inline deque<_Tp, _Allocator>& deque<_Tp, _Allocator>::operator=(deque&& __c) _NOEXCEPT_(
+    __alloc_traits::propagate_on_container_move_assignment::value&& is_nothrow_move_assignable<allocator_type>::value) {
+  __move_assign(__c, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__move_assign(deque& __c, false_type)
-{
-    if (__base::__alloc() != __c.__alloc())
-    {
-        typedef move_iterator<iterator> _Ip;
-        assign(_Ip(__c.begin()), _Ip(__c.end()));
-    }
-    else
-        __move_assign(__c, true_type());
+void deque<_Tp, _Allocator>::__move_assign(deque& __c, false_type) {
+  if (__base::__alloc() != __c.__alloc()) {
+  } else
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__move_assign(deque& __c, true_type)
-    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-{
-    clear();
-    shrink_to_fit();
-    __base::__move_assign(__c);
+void deque<_Tp, _Allocator>::__move_assign(deque& __c, true_type)
+    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
 template <class _InputIter>
-void
-deque<_Tp, _Allocator>::assign(_InputIter __f, _InputIter __l,
+void deque<_Tp, _Allocator>::assign(_InputIter __f, _InputIter __l,
                                     typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
-                                                 !__is_cpp17_random_access_iterator<_InputIter>::value>::type*)
-{
-    iterator __i = __base::begin();
-    iterator __e = __base::end();
-    for (; __f != __l && __i != __e; ++__f, (void) ++__i)
-        *__i = *__f;
-    if (__f != __l)
-        __append(__f, __l);
-    else
-        __erase_to_end(__i);
+                                                       !__is_cpp17_random_access_iterator<_InputIter>::value>::type*) {
+  for (; __f != __l && __i != __e; ++__f, (void)++__i)
 }
 
 template <class _Tp, class _Allocator>
 template <class _RAIter>
-void
-deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l,
-                               typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*)
-{
-    if (static_cast<size_type>(__l - __f) > __base::size())
-    {
-        _RAIter __m = __f + __base::size();
-        _VSTD::copy(__f, __m, __base::begin());
-        __append(__m, __l);
-    }
-    else
-        __erase_to_end(_VSTD::copy(__f, __l, __base::begin()));
+void deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l,
+                                    typename enable_if<__is_cpp17_random_access_iterator<_RAIter>::value>::type*) {
+  if (static_cast<size_type>(__l - __f) > __base::size()) {
+  } else
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v)
-{
-    if (__n > __base::size())
-    {
-        _VSTD::fill_n(__base::begin(), __base::size(), __v);
-        __n -= __base::size();
-        __append(__n, __v);
-    }
-    else
-        __erase_to_end(_VSTD::fill_n(__base::begin(), __n, __v));
+void deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v) {
+  if (__n > __base::size()) {
+  } else
 }
 
 template <class _Tp, class _Allocator>
-inline
-_Allocator
-deque<_Tp, _Allocator>::get_allocator() const _NOEXCEPT
-{
-    return __base::__alloc();
+inline _Allocator deque<_Tp, _Allocator>::get_allocator() const _NOEXCEPT {
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::resize(size_type __n)
-{
-    if (__n > __base::size())
-        __append(__n - __base::size());
-    else if (__n < __base::size())
-        __erase_to_end(__base::begin() + __n);
+void deque<_Tp, _Allocator>::resize(size_type __n) {
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::resize(size_type __n, const value_type& __v)
-{
-    if (__n > __base::size())
-        __append(__n - __base::size(), __v);
-    else if (__n < __base::size())
-        __erase_to_end(__base::begin() + __n);
+void deque<_Tp, _Allocator>::resize(size_type __n, const value_type& __v) {
 }
 
 template <class _Tp, class _Allocator>
-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);
-            __base::__map_.pop_back();
-        }
-        __base::__start_ = 0;
-    }
-    else
-    {
-      __maybe_remove_front_spare(/*__keep_one=*/false);
-      __maybe_remove_back_spare(/*__keep_one=*/false);
-    }
-    __base::__map_.shrink_to_fit();
+void deque<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT {
+  if (empty()) {
+    while (__base::__map_.size() > 0) {
+  } else {
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::reference
-deque<_Tp, _Allocator>::operator[](size_type __i) _NOEXCEPT
-{
-    size_type __p = __base::__start_ + __i;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::operator[](size_type __i) _NOEXCEPT {
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::const_reference
-deque<_Tp, _Allocator>::operator[](size_type __i) const _NOEXCEPT
-{
-    size_type __p = __base::__start_ + __i;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+inline typename deque<_Tp, _Allocator>::const_reference
+deque<_Tp, _Allocator>::operator[](size_type __i) const _NOEXCEPT {
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::reference
-deque<_Tp, _Allocator>::at(size_type __i)
-{
-    if (__i >= __base::size())
-        _VSTD::__throw_out_of_range("deque");
-    size_type __p = __base::__start_ + __i;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::at(size_type __i) {
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::const_reference
-deque<_Tp, _Allocator>::at(size_type __i) const
-{
-    if (__i >= __base::size())
-        _VSTD::__throw_out_of_range("deque");
-    size_type __p = __base::__start_ + __i;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+inline typename deque<_Tp, _Allocator>::const_reference deque<_Tp, _Allocator>::at(size_type __i) const {
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::reference
-deque<_Tp, _Allocator>::front() _NOEXCEPT
-{
-    return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size)
-                                      + __base::__start_ % __base::__block_size);
+inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::front() _NOEXCEPT {
+  return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size) +
+           __base::__start_ % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::const_reference
-deque<_Tp, _Allocator>::front() const _NOEXCEPT
-{
-    return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size)
-                                      + __base::__start_ % __base::__block_size);
+inline typename deque<_Tp, _Allocator>::const_reference deque<_Tp, _Allocator>::front() const _NOEXCEPT {
+  return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size) +
+           __base::__start_ % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::reference
-deque<_Tp, _Allocator>::back() _NOEXCEPT
-{
-    size_type __p = __base::size() + __base::__start_ - 1;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::back() _NOEXCEPT {
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::const_reference
-deque<_Tp, _Allocator>::back() const _NOEXCEPT
-{
-    size_type __p = __base::size() + __base::__start_ - 1;
-    return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
+inline typename deque<_Tp, _Allocator>::const_reference deque<_Tp, _Allocator>::back() const _NOEXCEPT {
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::push_back(const value_type& __v)
-{
-    allocator_type& __a = __base::__alloc();
-    if (__back_spare() == 0)
-        __add_back_capacity();
-    // __back_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
-    ++__base::size();
+void deque<_Tp, _Allocator>::push_back(const value_type& __v) {
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::push_front(const value_type& __v)
-{
-    allocator_type& __a = __base::__alloc();
-    if (__front_spare() == 0)
-        __add_front_capacity();
-    // __front_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
-    --__base::__start_;
-    ++__base::size();
+void deque<_Tp, _Allocator>::push_front(const value_type& __v) {
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::push_back(value_type&& __v)
-{
-    allocator_type& __a = __base::__alloc();
-    if (__back_spare() == 0)
-        __add_back_capacity();
-    // __back_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
-    ++__base::size();
+void deque<_Tp, _Allocator>::push_back(value_type&& __v) {
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
-#if _LIBCPP_STD_VER > 14
+#  if _LIBCPP_STD_VER > 14
 typename deque<_Tp, _Allocator>::reference
-#else
+#  else
 void
-#endif
-deque<_Tp, _Allocator>::emplace_back(_Args&&... __args)
-{
-    allocator_type& __a = __base::__alloc();
-    if (__back_spare() == 0)
-        __add_back_capacity();
-    // __back_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()),
-                              _VSTD::forward<_Args>(__args)...);
-    ++__base::size();
-#if _LIBCPP_STD_VER > 14
-    return *--__base::end();
-#endif
+#  endif
+deque<_Tp, _Allocator>::emplace_back(_Args&&... __args) {
+  __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...);
+#  if _LIBCPP_STD_VER > 14
+#  endif
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::push_front(value_type&& __v)
-{
-    allocator_type& __a = __base::__alloc();
-    if (__front_spare() == 0)
-        __add_front_capacity();
-    // __front_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
-    --__base::__start_;
-    ++__base::size();
+void deque<_Tp, _Allocator>::push_front(value_type&& __v) {
 }
 
-
 template <class _Tp, class _Allocator>
 template <class... _Args>
-#if _LIBCPP_STD_VER > 14
+#  if _LIBCPP_STD_VER > 14
 typename deque<_Tp, _Allocator>::reference
-#else
+#  else
 void
-#endif
-deque<_Tp, _Allocator>::emplace_front(_Args&&... __args)
-{
-    allocator_type& __a = __base::__alloc();
-    if (__front_spare() == 0)
-        __add_front_capacity();
-    // __front_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...);
-    --__base::__start_;
-    ++__base::size();
-#if _LIBCPP_STD_VER > 14
-    return *__base::begin();
-#endif
+#  endif
+deque<_Tp, _Allocator>::emplace_front(_Args&&... __args) {
+#  if _LIBCPP_STD_VER > 14
+#  endif
 }
 
 template <class _Tp, class _Allocator>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
-{
-    size_type __pos = __p - __base::begin();
-    size_type __to_end = __base::size() - __pos;
-    allocator_type& __a = __base::__alloc();
-    if (__pos < __to_end)
-    {   // insert by shifting things backward
-        if (__front_spare() == 0)
-            __add_front_capacity();
-        // __front_spare() >= 1
-        if (__pos == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
-            --__base::__start_;
-            ++__base::size();
-        }
-        else
-        {
-            iterator __b = __base::begin();
-            iterator __bm1 = _VSTD::prev(__b);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
-            --__base::__start_;
-            ++__base::size();
-            if (__pos > 1)
-                __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
-            *__b = _VSTD::move(__v);
-        }
-    }
-    else
-    {   // insert by shifting things forward
-        if (__back_spare() == 0)
-            __add_back_capacity();
-        // __back_capacity >= 1
-        size_type __de = __base::size() - __pos;
-        if (__de == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
-            ++__base::size();
-        }
-        else
-        {
-            iterator __e = __base::end();
-            iterator __em1 = _VSTD::prev(__e);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
-            ++__base::size();
-            if (__de > 1)
-                __e = _VSTD::move_backward(__e - __de, __em1, __e);
-            *--__e = _VSTD::move(__v);
-        }
-    }
-    return __base::begin() + __pos;
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v) {
+  if (__pos < __to_end) { // insert by shifting things backward
+    if (__pos == 0) {
+    } else {
+  } else { // insert by shifting things forward
+    if (__de == 0) {
+    } else {
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
-{
-    size_type __pos = __p - __base::begin();
-    size_type __to_end = __base::size() - __pos;
-    allocator_type& __a = __base::__alloc();
-    if (__pos < __to_end)
-    {   // insert by shifting things backward
-        if (__front_spare() == 0)
-            __add_front_capacity();
-        // __front_spare() >= 1
-        if (__pos == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...);
-            --__base::__start_;
-            ++__base::size();
-        }
-        else
-        {
-            __temp_value<value_type, _Allocator> __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...);
-            iterator __b = __base::begin();
-            iterator __bm1 = _VSTD::prev(__b);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
-            --__base::__start_;
-            ++__base::size();
-            if (__pos > 1)
-                __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
-            *__b = _VSTD::move(__tmp.get());
-        }
-    }
-    else
-    {   // insert by shifting things forward
-        if (__back_spare() == 0)
-            __add_back_capacity();
-        // __back_capacity >= 1
-        size_type __de = __base::size() - __pos;
-        if (__de == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...);
-            ++__base::size();
-        }
-        else
-        {
-            __temp_value<value_type, _Allocator> __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...);
-            iterator __e = __base::end();
-            iterator __em1 = _VSTD::prev(__e);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
-            ++__base::size();
-            if (__de > 1)
-                __e = _VSTD::move_backward(__e - __de, __em1, __e);
-            *--__e = _VSTD::move(__tmp.get());
-        }
-    }
-    return __base::begin() + __pos;
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args) {
+  if (__pos < __to_end) { // insert by shifting things backward
+    if (__pos == 0) {
+    } else {
+  } else { // insert by shifting things forward
+    if (__de == 0) {
+    } else {
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
-
 template <class _Tp, class _Allocator>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
-{
-    size_type __pos = __p - __base::begin();
-    size_type __to_end = __base::size() - __pos;
-    allocator_type& __a = __base::__alloc();
-    if (__pos < __to_end)
-    {   // insert by shifting things backward
-        if (__front_spare() == 0)
-            __add_front_capacity();
-        // __front_spare() >= 1
-        if (__pos == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
-            --__base::__start_;
-            ++__base::size();
-        }
-        else
-        {
-            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
-            iterator __b = __base::begin();
-            iterator __bm1 = _VSTD::prev(__b);
-            if (__vt == pointer_traits<const_pointer>::pointer_to(*__b))
-                __vt = pointer_traits<const_pointer>::pointer_to(*__bm1);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
-            --__base::__start_;
-            ++__base::size();
-            if (__pos > 1)
-                __b = __move_and_check(_VSTD::next(__b), __b + __pos, __b, __vt);
-            *__b = *__vt;
-        }
-    }
-    else
-    {   // insert by shifting things forward
-        if (__back_spare() == 0)
-            __add_back_capacity();
-        // __back_capacity >= 1
-        size_type __de = __base::size() - __pos;
-        if (__de == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
-            ++__base::size();
-        }
-        else
-        {
-            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
-            iterator __e = __base::end();
-            iterator __em1 = _VSTD::prev(__e);
-            if (__vt == pointer_traits<const_pointer>::pointer_to(*__em1))
-                __vt = pointer_traits<const_pointer>::pointer_to(*__e);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
-            ++__base::size();
-            if (__de > 1)
-                __e = __move_backward_and_check(__e - __de, __em1, __e, __vt);
-            *--__e = *__vt;
-        }
-    }
-    return __base::begin() + __pos;
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v) {
+  if (__pos < __to_end) { // insert by shifting things backward
+    if (__pos == 0) {
+    } else {
+  } else { // insert by shifting things forward
+    if (__de == 0) {
+    } else {
 }
 
 template <class _Tp, class _Allocator>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_type& __v)
-{
-    size_type __pos = __p - __base::begin();
-    size_type __to_end = __base::size() - __pos;
-    allocator_type& __a = __base::__alloc();
-    if (__pos < __to_end)
-    {   // insert by shifting things backward
-        if (__n > __front_spare())
-            __add_front_capacity(__n - __front_spare());
-        // __n <= __front_spare()
-        iterator __old_begin = __base::begin();
-        iterator __i = __old_begin;
-        if (__n > __pos)
-        {
-            for (size_type __m = __n - __pos; __m; --__m, --__base::__start_, ++__base::size())
-                __alloc_traits::construct(__a, _VSTD::addressof(*--__i), __v);
-            __n = __pos;
-        }
-        if (__n > 0)
-        {
-            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
-            iterator __obn = __old_begin + __n;
-            __move_construct_backward_and_check(__old_begin, __obn, __i, __vt);
-            if (__n < __pos)
-                __old_begin = __move_and_check(__obn, __old_begin + __pos, __old_begin, __vt);
-            _VSTD::fill_n(__old_begin, __n, *__vt);
-        }
-    }
-    else
-    {   // insert by shifting things forward
-        size_type __back_capacity = __back_spare();
-        if (__n > __back_capacity)
-            __add_back_capacity(__n - __back_capacity);
-        // __n <= __back_capacity
-        iterator __old_end = __base::end();
-        iterator __i = __old_end;
-        size_type __de = __base::size() - __pos;
-        if (__n > __de)
-        {
-            for (size_type __m = __n - __de; __m; --__m, (void) ++__i, ++__base::size())
-                __alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);
-            __n = __de;
-        }
-        if (__n > 0)
-        {
-            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
-            iterator __oen = __old_end - __n;
-            __move_construct_and_check(__oen, __old_end, __i, __vt);
-            if (__n < __de)
-                __old_end = __move_backward_and_check(__old_end - __de, __oen, __old_end, __vt);
-            _VSTD::fill_n(__old_end - __n, __n, *__vt);
-        }
-    }
-    return __base::begin() + __pos;
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n,
+                                                                         const value_type& __v) {
+  if (__pos < __to_end) { // insert by shifting things backward
+    if (__n > __pos) {
+    if (__n > 0) {
+  } else { // insert by shifting things forward
+    if (__n > __de) {
+      for (size_type __m = __n - __de; __m; --__m, (void)++__i, ++__base::size())
+    if (__n > 0) {
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __l,
-                               typename enable_if<__is_cpp17_input_iterator<_InputIter>::value
-                                               &&!__is_cpp17_forward_iterator<_InputIter>::value>::type*)
-{
-    __split_buffer<value_type, allocator_type&> __buf(__base::__alloc());
-    __buf.__construct_at_end(__f, __l);
-    typedef typename __split_buffer<value_type, allocator_type&>::iterator __bi;
-    return insert(__p, move_iterator<__bi>(__buf.begin()), move_iterator<__bi>(__buf.end()));
+                               typename enable_if<__is_cpp17_input_iterator<_InputIter>::value &&
+                                                  !__is_cpp17_forward_iterator<_InputIter>::value>::type*) {
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
-                               typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value
-                                               &&!__is_cpp17_bidirectional_iterator<_ForwardIterator>::value>::type*)
-{
-    size_type __n = _VSTD::distance(__f, __l);
-    __split_buffer<value_type, allocator_type&> __buf(__n, 0, __base::__alloc());
-    __buf.__construct_at_end(__f, __l);
-    typedef typename __split_buffer<value_type, allocator_type&>::iterator __fwd;
-    return insert(__p, move_iterator<__fwd>(__buf.begin()), move_iterator<__fwd>(__buf.end()));
+                               typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value &&
+                                                  !__is_cpp17_bidirectional_iterator<_ForwardIterator>::value>::type*) {
 }
 
 template <class _Tp, class _Allocator>
 template <class _BiIter>
 typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
-                               typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type*)
-{
-    size_type __n = _VSTD::distance(__f, __l);
-    size_type __pos = __p - __base::begin();
-    size_type __to_end = __base::size() - __pos;
-    allocator_type& __a = __base::__alloc();
-    if (__pos < __to_end)
-    {   // insert by shifting things backward
-        if (__n > __front_spare())
-            __add_front_capacity(__n - __front_spare());
-        // __n <= __front_spare()
-        iterator __old_begin = __base::begin();
-        iterator __i = __old_begin;
-        _BiIter __m = __f;
-        if (__n > __pos)
-        {
-            __m = __pos < __n / 2 ? _VSTD::prev(__l, __pos) : _VSTD::next(__f, __n - __pos);
-            for (_BiIter __j = __m; __j != __f; --__base::__start_, ++__base::size())
-                __alloc_traits::construct(__a, _VSTD::addressof(*--__i), *--__j);
-            __n = __pos;
-        }
-        if (__n > 0)
-        {
-            iterator __obn = __old_begin + __n;
-            for (iterator __j = __obn; __j != __old_begin;)
-            {
-                __alloc_traits::construct(__a, _VSTD::addressof(*--__i), _VSTD::move(*--__j));
-                --__base::__start_;
-                ++__base::size();
-            }
-            if (__n < __pos)
-                __old_begin = _VSTD::move(__obn, __old_begin + __pos, __old_begin);
-            _VSTD::copy(__m, __l, __old_begin);
-        }
-    }
-    else
-    {   // insert by shifting things forward
-        size_type __back_capacity = __back_spare();
-        if (__n > __back_capacity)
-            __add_back_capacity(__n - __back_capacity);
-        // __n <= __back_capacity
-        iterator __old_end = __base::end();
-        iterator __i = __old_end;
-        _BiIter __m = __l;
-        size_type __de = __base::size() - __pos;
-        if (__n > __de)
-        {
-            __m = __de < __n / 2 ? _VSTD::next(__f, __de) : _VSTD::prev(__l, __n - __de);
-            for (_BiIter __j = __m; __j != __l; ++__i, (void) ++__j, ++__base::size())
-                __alloc_traits::construct(__a, _VSTD::addressof(*__i), *__j);
-            __n = __de;
-        }
-        if (__n > 0)
-        {
-            iterator __oen = __old_end - __n;
-            for (iterator __j = __oen; __j != __old_end; ++__i, (void) ++__j, ++__base::size())
-                __alloc_traits::construct(__a, _VSTD::addressof(*__i), _VSTD::move(*__j));
-            if (__n < __de)
-                __old_end = _VSTD::move_backward(__old_end - __de, __oen, __old_end);
-            _VSTD::copy_backward(__f, __m, __old_end);
-        }
-    }
-    return __base::begin() + __pos;
+                               typename enable_if<__is_cpp17_bidirectional_iterator<_BiIter>::value>::type*) {
+  if (__pos < __to_end) { // insert by shifting things backward
+    if (__n > __pos) {
+    if (__n > 0) {
+      for (iterator __j = __obn; __j != __old_begin;) {
+  } else { // insert by shifting things forward
+    if (__n > __de) {
+      for (_BiIter __j = __m; __j != __l; ++__i, (void)++__j, ++__base::size())
+    if (__n > 0) {
+      for (iterator __j = __oen; __j != __old_end; ++__i, (void)++__j, ++__base::size())
 }
 
 template <class _Tp, class _Allocator>
 template <class _InpIter>
-void
-deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l,
+void deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l,
                                       typename enable_if<__is_cpp17_input_iterator<_InpIter>::value &&
-                                                   !__is_cpp17_forward_iterator<_InpIter>::value>::type*)
-{
-    for (; __f != __l; ++__f)
+                                                         !__is_cpp17_forward_iterator<_InpIter>::value>::type*) {
 #ifdef _LIBCPP_CXX03_LANG
-        push_back(*__f);
 #else
-        emplace_back(*__f);
 #endif
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForIter>
-void
-deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
-                                 typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type*)
-{
-    size_type __n = _VSTD::distance(__f, __l);
-    allocator_type& __a = __base::__alloc();
-    size_type __back_capacity = __back_spare();
-    if (__n > __back_capacity)
-        __add_back_capacity(__n - __back_capacity);
-    // __n <= __back_capacity
-    for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
-      _ConstructTransaction __tx(this, __br);
-      for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__f) {
-        __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), *__f);
-      }
-    }
+void deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
+                                      typename enable_if<__is_cpp17_forward_iterator<_ForIter>::value>::type*) {
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__append(size_type __n)
-{
-    allocator_type& __a = __base::__alloc();
-    size_type __back_capacity = __back_spare();
-    if (__n > __back_capacity)
-        __add_back_capacity(__n - __back_capacity);
-    // __n <= __back_capacity
-    for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
-      _ConstructTransaction __tx(this, __br);
-      for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
-        __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_));
-      }
-    }
+void deque<_Tp, _Allocator>::__append(size_type __n) {
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)
-{
-    allocator_type& __a = __base::__alloc();
-    size_type __back_capacity = __back_spare();
-    if (__n > __back_capacity)
-        __add_back_capacity(__n - __back_capacity);
-    // __n <= __back_capacity
-    for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
-      _ConstructTransaction __tx(this, __br);
-      for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
-        __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), __v);
-      }
-    }
-
+void deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v) {
 }
 
 // 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)
-    {
-        __base::__start_ += __base::__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));
-        else
-        {
-            __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__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;
-    }
-    // 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());
+void deque<_Tp, _Allocator>::__add_front_capacity() {
+  if (__back_spare() >= __base::__block_size) {
+  else if (__base::__map_.size() <
+           __base::__map_.capacity()) { // we can put the new buffer into the map, but don't shift things around
+    else {
+    __base::__start_ = __base::__map_.size() == 1 ? __base::__block_size / 2 : __base::__start_ + __base::__block_size;
+  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),
+    unique_ptr<pointer, _Dp> __hold(__alloc_traits::allocate(__a, __base::__block_size),
                                     _Dp(__a, __base::__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;
-    }
+    for (typename __base::__map_pointer __i = __base::__map_.begin(); __i != __base::__map_.end(); ++__i)
+    __base::__start_ = __base::__map_.size() == 1 ? __base::__block_size / 2 : __base::__start_ + __base::__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;
-    __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;
-        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))
-        {
-            if (__base::__map_.__front_spare() == 0)
-                break;
-            __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
-        }
-        for (; __nb > 0; --__nb, ++__back_capacity)
-            __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
-        // Done allocating, reorder capacity
-        __base::__start_ += __back_capacity * __base::__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();
-        __split_buffer<pointer, typename __base::__pointer_allocator&>
-            __buf(max<size_type>(2* __base::__map_.capacity(),
-                                 __nb + __base::__map_.size()),
-                  0, __base::__map_.__alloc());
+void deque<_Tp, _Allocator>::__add_front_capacity(size_type __n) {
+  __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) {
+    for (; __back_capacity > 0; --__back_capacity) {
+  else if (__nb <=
+           __base::__map_.capacity() -
+               __base::__map_.size()) { // we can put the new buffers into the map, but don't shift things around
+    for (; __nb > 0; --__nb, __base::__start_ += __base::__block_size - (__base::__map_.size() == 1)) {
+    for (; __back_capacity > 0; --__back_capacity) {
+  else {
+    __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
-        {
+    try {
 #endif // _LIBCPP_NO_EXCEPTIONS
-            for (; __nb > 0; --__nb)
-                __buf.push_back(__alloc_traits::allocate(__a, __base::__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);
-            throw;
-        }
+    } catch (...) {
+      for (typename __base::__map_pointer __i = __buf.begin(); __i != __buf.end(); ++__i)
 #endif // _LIBCPP_NO_EXCEPTIONS
-        for (; __back_capacity > 0; --__back_capacity)
-        {
-            __buf.push_back(__base::__map_.back());
-            __base::__map_.pop_back();
-        }
-        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_ += __ds;
-    }
+    for (; __back_capacity > 0; --__back_capacity) {
+    for (typename __base::__map_pointer __i = __base::__map_.begin(); __i != __base::__map_.end(); ++__i)
 }
 
 // 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)
-    {
-        __base::__start_ -= __base::__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));
-        else
-        {
-            __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__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());
+void deque<_Tp, _Allocator>::__add_back_capacity() {
+  if (__front_spare() >= __base::__block_size) {
+  else if (__base::__map_.size() <
+           __base::__map_.capacity()) { // we can put the new buffer into the map, but don't shift things around
+    else {
+  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),
+    unique_ptr<pointer, _Dp> __hold(__alloc_traits::allocate(__a, __base::__block_size),
                                     _Dp(__a, __base::__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());
-    }
+    for (typename __base::__map_pointer __i = __base::__map_.end(); __i != __base::__map_.begin();)
 }
 
 // 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;
-    __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;
-        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));
-        }
-        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));
-        // Done allocating, reorder capacity
-        __base::__start_ -= __base::__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;
-        __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());
+void deque<_Tp, _Allocator>::__add_back_capacity(size_type __n) {
+  __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) {
+    for (; __front_capacity > 0; --__front_capacity) {
+  else if (__nb <=
+           __base::__map_.capacity() -
+               __base::__map_.size()) { // we can put the new buffers into the map, but don't shift things around
+    for (; __nb > 0; --__nb) {
+    for (; __nb > 0;
+         --__nb, ++__front_capacity, __base::__start_ += __base::__block_size - (__base::__map_.size() == 1))
+    for (; __front_capacity > 0; --__front_capacity) {
+  else {
+    __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
-        {
+    try {
 #endif // _LIBCPP_NO_EXCEPTIONS
-            for (; __nb > 0; --__nb)
-                __buf.push_back(__alloc_traits::allocate(__a, __base::__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);
-            throw;
-        }
+    } catch (...) {
+      for (typename __base::__map_pointer __i = __buf.begin(); __i != __buf.end(); ++__i)
 #endif // _LIBCPP_NO_EXCEPTIONS
-        for (; __front_capacity > 0; --__front_capacity)
-        {
-            __buf.push_back(__base::__map_.front());
-            __base::__map_.pop_front();
-        }
-        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());
-        __base::__start_ -= __ds;
-    }
+    for (; __front_capacity > 0; --__front_capacity) {
+    for (typename __base::__map_pointer __i = __base::__map_.end(); __i != __base::__map_.begin();)
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::pop_front()
-{
-    allocator_type& __a = __base::__alloc();
-    __alloc_traits::destroy(__a, _VSTD::__to_address(*(__base::__map_.begin() +
-                                                    __base::__start_ / __base::__block_size) +
-                                                    __base::__start_ % __base::__block_size));
-    --__base::size();
-    ++__base::__start_;
-    __maybe_remove_front_spare();
+void deque<_Tp, _Allocator>::pop_front() {
+  __alloc_traits::destroy(__a, _VSTD::__to_address(*(__base::__map_.begin() + __base::__start_ / __base::__block_size) +
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::pop_back()
-{
-    _LIBCPP_ASSERT(!empty(), "deque::pop_back called on an empty deque");
-    allocator_type& __a = __base::__alloc();
-    size_type __p = __base::size() + __base::__start_ - 1;
-    __alloc_traits::destroy(__a, _VSTD::__to_address(*(__base::__map_.begin() +
-                                                    __p / __base::__block_size) +
-                                                    __p % __base::__block_size));
-    --__base::size();
-    __maybe_remove_back_spare();
+void deque<_Tp, _Allocator>::pop_back() {
+  __alloc_traits::destroy(
+      __a, _VSTD::__to_address(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size));
 }
 
 // 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;
-        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_;
-        __r = _VSTD::move(__fb, __fe, __r);
-        __n -= __bs;
-        __f += __bs;
-    }
-    return __r;
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l,
+                                                                                   iterator __r, const_pointer& __vt) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
 // move assign [__f, __l) to [__r - (__l-__f), __r) backwards.
 // If __vt points into [__f, __l), then add (__r - __l) to __vt.
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::__move_backward_and_check(iterator __f, iterator __l, iterator __r,
-                                                  const_pointer& __vt)
-{
-    // as if
-    //   while (__f != __l)
-    //       *--__r = _VSTD::move(*--__l);
-    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;
-        }
-        if (__lb <= __vt && __vt < __le)
-            __vt = (const_iterator(static_cast<__map_const_pointer>(__l.__m_iter_), __vt) += __r - __l - 1).__ptr_;
-        __r = _VSTD::move_backward(__lb, __le, __r);
-        __n -= __bs;
-        __l -= __bs - 1;
-    }
-    return __r;
+deque<_Tp, _Allocator>::__move_backward_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
 // move construct [__f, __l) to [__r, __r + (__l-__f)).
 // If __vt points into [__f, __l), then add (__r - __f) to __vt.
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
-                                                   iterator __r, const_pointer& __vt)
-{
-    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;
-        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_;
-        for (; __fb != __fe; ++__fb, ++__r, ++__base::size())
-            __alloc_traits::construct(__a, _VSTD::addressof(*__r), _VSTD::move(*__fb));
-        __n -= __bs;
-        __f += __bs;
-    }
+void deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt) {
+  while (__n > 0) {
+    if (__bs > __n) {
 }
 
 // move construct [__f, __l) to [__r - (__l-__f), __r) backwards.
 // If __vt points into [__f, __l), then subtract (__l - __r) from __vt.
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterator __l,
-                                                            iterator __r, const_pointer& __vt)
-{
-    allocator_type& __a = __base::__alloc();
-    // as if
-    //   for (iterator __j = __l; __j != __f;)
-    //   {
-    //       __alloc_traitsconstruct(__a, _VSTD::addressof(*--__r), _VSTD::move(*--__j));
-    //       --__base::__start_;
-    //       ++__base::size();
-    //   }
-    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;
-        }
-        if (__lb <= __vt && __vt < __le)
-            __vt = (const_iterator(static_cast<__map_const_pointer>(__l.__m_iter_), __vt) -= __l - __r + 1).__ptr_;
-        while (__le != __lb)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*--__r), _VSTD::move(*--__le));
-            --__base::__start_;
-            ++__base::size();
-        }
-        __n -= __bs;
-        __l -= __bs - 1;
-    }
+void deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterator __l, iterator __r,
+                                                                 const_pointer& __vt) {
+  while (__n > 0) {
+    if (__bs > __n) {
+    while (__le != __lb) {
 }
 
 template <class _Tp, class _Allocator>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::erase(const_iterator __f)
-{
-    iterator __b = __base::begin();
-    difference_type __pos = __f - __b;
-    iterator __p = __b + __pos;
-    allocator_type& __a = __base::__alloc();
-    if (static_cast<size_t>(__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_;
-        __maybe_remove_front_spare();
-    }
-    else
-    {   // erase from back
-        iterator __i = _VSTD::move(_VSTD::next(__p), __base::end(), __p);
-        __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
-        --__base::size();
-        __maybe_remove_back_spare();
-    }
-    return __base::begin() + __pos;
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::erase(const_iterator __f) {
+  if (static_cast<size_t>(__pos) <= (__base::size() - 1) / 2) { // erase from front
+  } else { // erase from back
 }
 
 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 (static_cast<size_t>(__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 (__maybe_remove_front_spare()) {
-            }
-        }
-        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 (__maybe_remove_back_spare()) {
-            }
-        }
-    }
-    return __base::begin() + __pos;
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l) {
+  if (__n > 0) {
+    if (static_cast<size_t>(__pos) <= (__base::size() - __n) / 2) { // erase from front
+    } else { // erase from back
 }
 
 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 (__maybe_remove_back_spare()) {
-        }
-    }
+void deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f) {
+  if (__n > 0) {
 }
 
 template <class _Tp, class _Allocator>
-inline
-void
-deque<_Tp, _Allocator>::swap(deque& __c)
+inline void deque<_Tp, _Allocator>::swap(deque& __c)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<allocator_type>::value)
+    _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<allocator_type>::value)
 #endif
 {
-    __base::swap(__c);
 }
 
 template <class _Tp, class _Allocator>
-inline
-void
-deque<_Tp, _Allocator>::clear() _NOEXCEPT
-{
-    __base::clear();
+inline void deque<_Tp, _Allocator>::clear() _NOEXCEPT {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    const typename deque<_Tp, _Allocator>::size_type __sz = __x.size();
-    return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
+inline _LIBCPP_INLINE_VISIBILITY bool operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+inline _LIBCPP_INLINE_VISIBILITY bool operator<(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator> (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_INLINE_VISIBILITY bool operator>(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_INLINE_VISIBILITY bool operator>=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_INLINE_VISIBILITY bool operator<=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_INLINE_VISIBILITY void swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, class _Allocator, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY typename deque<_Tp, _Allocator>::size_type
-erase(deque<_Tp, _Allocator>& __c, const _Up& __v) {
+inline _LIBCPP_INLINE_VISIBILITY typename deque<_Tp, _Allocator>::size_type erase(deque<_Tp, _Allocator>& __c,
+                                                                                  const _Up& __v) {
   auto __old_size = __c.size();
   __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end());
   return __old_size - __c.size();
 }
 
 template <class _Tp, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY typename deque<_Tp, _Allocator>::size_type
-erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred) {
+inline _LIBCPP_INLINE_VISIBILITY typename deque<_Tp, _Allocator>::size_type erase_if(deque<_Tp, _Allocator>& __c,
+                                                                                     _Predicate __pred) {
   auto __old_size = __c.size();
   __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end());
   return __old_size - __c.size();
 }
 #endif
 
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_DEQUE

libcxx/include/forward_list

template <class T, class Allocator, class Predicate>
     typename forward_list<T, Allocator>::size_type
     erase_if(forward_list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
+#include <__memory/is_allocator.h>
+#include <__memory/swap_allocator.h>
 #include <__utility/forward.h>
 #include <algorithm>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>

libcxx/include/list

template <class T, class Allocator, class Predicate>
     erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
+#include <__memory/is_allocator.h>
+#include <__memory/swap_allocator.h>
 #include <__utility/forward.h>
 #include <algorithm>
 #include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <type_traits>
 #include <version>

libcxx/include/map

 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__iterator/iterator_traits.h>
+#include <__memory/is_allocator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <compare>
 #include <functional>
 #include <initializer_list>
 #include <iterator> // __libcpp_erase_if_container
 #include <memory>

libcxx/include/memory

 #include <__memory/compressed_pair.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/raw_storage_iterator.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/temporary_buffer.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
 #include <compare>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <iosfwd>
 #include <iterator>
 #include <new>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
 #include <utility>
 #include <version>
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 #   include <__memory/auto_ptr.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Alloc, class _Ptr>
-_LIBCPP_INLINE_VISIBILITY
-void __construct_forward_with_exception_guarantees(_Alloc& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2) {
-    static_assert(__is_cpp17_move_insertable<_Alloc>::value,
-        "The specified type does not meet the requirements of Cpp17MoveInsertable");
-    typedef allocator_traits<_Alloc> _Traits;
-    for (; __begin1 != __end1; ++__begin1, (void)++__begin2) {
-        _Traits::construct(__a, _VSTD::__to_address(__begin2),
-#ifdef _LIBCPP_NO_EXCEPTIONS
-            _VSTD::move(*__begin1)
-#else
-            _VSTD::move_if_noexcept(*__begin1)
-#endif
-        );
-    }
-}
-
-template <class _Alloc, class _Tp, typename enable_if<
-    (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Tp*, _Tp>::value) &&
-    is_trivially_move_constructible<_Tp>::value
->::type>
-_LIBCPP_INLINE_VISIBILITY
-void __construct_forward_with_exception_guarantees(_Alloc&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2) {
-    ptrdiff_t _Np = __end1 - __begin1;
-    if (_Np > 0) {
-        _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp));
-        __begin2 += _Np;
-    }
-}
-
-template <class _Alloc, class _Iter, class _Ptr>
-_LIBCPP_INLINE_VISIBILITY
-void __construct_range_forward(_Alloc& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2) {
-    typedef allocator_traits<_Alloc> _Traits;
-    for (; __begin1 != __end1; ++__begin1, (void) ++__begin2) {
-        _Traits::construct(__a, _VSTD::__to_address(__begin2), *__begin1);
-    }
-}
-
-template <class _Alloc, class _Source, class _Dest,
-          class _RawSource = typename remove_const<_Source>::type,
-          class _RawDest = typename remove_const<_Dest>::type,
-          class =
-    typename enable_if<
-        is_trivially_copy_constructible<_Dest>::value &&
-        is_same<_RawSource, _RawDest>::value &&
-        (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Dest*, _Source&>::value)
-    >::type>
-_LIBCPP_INLINE_VISIBILITY
-void __construct_range_forward(_Alloc&, _Source* __begin1, _Source* __end1, _Dest*& __begin2) {
-    ptrdiff_t _Np = __end1 - __begin1;
-    if (_Np > 0) {
-        _VSTD::memcpy(const_cast<_RawDest*>(__begin2), __begin1, _Np * sizeof(_Dest));
-        __begin2 += _Np;
-    }
-}
-
-template <class _Alloc, class _Ptr>
-_LIBCPP_INLINE_VISIBILITY
-void __construct_backward_with_exception_guarantees(_Alloc& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2) {
-    static_assert(__is_cpp17_move_insertable<_Alloc>::value,
-        "The specified type does not meet the requirements of Cpp17MoveInsertable");
-    typedef allocator_traits<_Alloc> _Traits;
-    while (__end1 != __begin1) {
-        _Traits::construct(__a, _VSTD::__to_address(__end2 - 1),
-#ifdef _LIBCPP_NO_EXCEPTIONS
-            _VSTD::move(*--__end1)
-#else
-            _VSTD::move_if_noexcept(*--__end1)
-#endif
-        );
-        --__end2;
-    }
-}
-
-template <class _Alloc, class _Tp, class = typename enable_if<
-    (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Tp*, _Tp>::value) &&
-    is_trivially_move_constructible<_Tp>::value
->::type>
-_LIBCPP_INLINE_VISIBILITY
-void __construct_backward_with_exception_guarantees(_Alloc&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2) {
-    ptrdiff_t _Np = __end1 - __begin1;
-    __end2 -= _Np;
-    if (_Np > 0)
-        _VSTD::memcpy(static_cast<void*>(__end2), static_cast<void const*>(__begin1), _Np * sizeof(_Tp));
-}
-
-struct __destruct_n
-{
-private:
-    size_t __size_;
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT
-        {for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();}
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT
-        {}
-
-    _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT
-        {++__size_;}
-    _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT
-        {}
-
-    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT
-        {__size_ = __s;}
-    _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT
-        {}
-public:
-    _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT
-        : __size_(__s) {}
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __incr() _NOEXCEPT
-        {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT
-        {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT
-        {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
-};
-
 _LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
 
-// --- Helper for container swap --
-template <typename _Alloc>
-_LIBCPP_INLINE_VISIBILITY
-void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type)
-#if _LIBCPP_STD_VER >= 14
-    _NOEXCEPT
-#else
-    _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
-#endif
-{
-    using _VSTD::swap;
-    swap(__a1, __a2);
-}
-
-template <typename _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {}
-
-template <typename _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
-#if _LIBCPP_STD_VER >= 14
-    _NOEXCEPT
-#else
-    _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
-#endif
-{
-    _VSTD::__swap_allocator(__a1, __a2,
-      integral_constant<bool, allocator_traits<_Alloc>::propagate_on_container_swap::value>());
-}
-
-template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
-struct __noexcept_move_assign_container : public integral_constant<bool,
-    _Traits::propagate_on_container_move_assignment::value
-#if _LIBCPP_STD_VER > 14
-        || _Traits::is_always_equal::value
-#else
-        && is_nothrow_move_assignable<_Alloc>::value
-#endif
-    > {};
-
-
-template <class _Tp, class _Alloc>
-struct __temp_value {
-    typedef allocator_traits<_Alloc> _Traits;
-
-    typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
-    _Alloc &__a;
-
-    _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); }
-    _Tp &   get() { return *__addr(); }
-
-    template<class... _Args>
-    _LIBCPP_NO_CFI
-    __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
-      _Traits::construct(__a, reinterpret_cast<_Tp*>(addressof(__v)),
-                         _VSTD::forward<_Args>(__args)...);
-    }
-
-    ~__temp_value() { _Traits::destroy(__a, __addr()); }
-    };
-
-template<typename _Alloc, typename = void, typename = void>
-struct __is_allocator : false_type {};
-
-template<typename _Alloc>
-struct __is_allocator<_Alloc,
-       typename __void_t<typename _Alloc::value_type>::type,
-       typename __void_t<decltype(declval<_Alloc&>().allocate(size_t(0)))>::type
-     >
-   : true_type {};
-
-// __builtin_new_allocator -- A non-templated helper for allocating and
-// deallocating memory using __builtin_operator_new and
-// __builtin_operator_delete. It should be used in preference to
-// `std::allocator<T>` to avoid additional instantiations.
-struct __builtin_new_allocator {
-  struct __builtin_new_deleter {
-    typedef void* pointer_type;
-
-    _LIBCPP_CONSTEXPR explicit __builtin_new_deleter(size_t __size, size_t __align)
-        : __size_(__size), __align_(__align) {}
-
-    void operator()(void* p) const _NOEXCEPT {
-        _VSTD::__libcpp_deallocate(p, __size_, __align_);
-    }
-
-   private:
-    size_t __size_;
-    size_t __align_;
-  };
-
-  typedef unique_ptr<void, __builtin_new_deleter> __holder_t;
-
-  static __holder_t __allocate_bytes(size_t __s, size_t __align) {
-      return __holder_t(_VSTD::__libcpp_allocate(__s, __align),
-                     __builtin_new_deleter(__s, __align));
-  }
-
-  static void __deallocate_bytes(void* __p, size_t __s,
-                                 size_t __align) _NOEXCEPT {
-      _VSTD::__libcpp_deallocate(__p, __s, __align);
-  }
-
-  template <class _Tp>
-  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
-  static __holder_t __allocate_type(size_t __n) {
-      return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
-  }
-
-  template <class _Tp>
-  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
-  static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
-      __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
-  }
-};
-
-
 _LIBCPP_END_NAMESPACE_STD
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_memory>
 #endif
 
 #endif // _LIBCPP_MEMORY

libcxx/include/module.modulemap

module __algorithm {
       module comp                     { private header "__algorithm/comp.h" }
       module comp_ref_type            { private header "__algorithm/comp_ref_type.h" }
       module copy                     { private header "__algorithm/copy.h" }
       module copy_backward            { private header "__algorithm/copy_backward.h" }
       module copy_if                  { private header "__algorithm/copy_if.h" }
       module copy_n                   { private header "__algorithm/copy_n.h" }
       module count                    { private header "__algorithm/count.h" }
       module count_if                 { private header "__algorithm/count_if.h" }
+      module destruct_n               { private header "__algorithm/destruct_n.h" }
       module equal                    { private header "__algorithm/equal.h" }
       module equal_range              { private header "__algorithm/equal_range.h" }
       module fill                     { private header "__algorithm/fill.h" }
       module fill_n                   { private header "__algorithm/fill_n.h" }
       module find                     { private header "__algorithm/find.h" }
       module find_end                 { private header "__algorithm/find_end.h" }
       module find_first_of            { private header "__algorithm/find_first_of.h" }
       module find_if                  { private header "__algorithm/find_if.h" }
module functional {
     module __functional {
       module binary_function            { private header "__functional/binary_function.h" }
       module binary_negate              { private header "__functional/binary_negate.h" }
       module bind                       { private header "__functional/bind.h" }
       module bind_back                  { private header "__functional/bind_back.h" }
       module bind_front                 { private header "__functional/bind_front.h" }
       module binder1st                  { private header "__functional/binder1st.h" }
       module binder2nd                  { private header "__functional/binder2nd.h" }
+      module builtin_new_allocator      { private header "__functional/builtin_new_allocator.h" }
       module compose                    { private header "__functional/compose.h" }
       module default_searcher           { private header "__functional/default_searcher.h" }
       module function                   { private header "__functional/function.h" }
       module hash                       { private header "__functional/hash.h" }
       module identity                   { private header "__functional/identity.h" }
       module invoke                     { private header "__functional/invoke.h" }
       module is_transparent             { private header "__functional/is_transparent.h" }
       module mem_fn                     { private header "__functional/mem_fn.h"  }
module map {
     export initializer_list
     export *
   }
   module memory {
     header "memory"
     export *
 
     module __memory {
-      module addressof                { private header "__memory/addressof.h"                }
-      module allocation_guard         { private header "__memory/allocation_guard.h"         }
-      module allocator                { private header "__memory/allocator.h"                }
-      module allocator_arg_t          { private header "__memory/allocator_arg_t.h"          }
-      module allocator_traits         { private header "__memory/allocator_traits.h"         }
-      module auto_ptr                 { private header "__memory/auto_ptr.h"                 }
-      module compressed_pair          { private header "__memory/compressed_pair.h"          }
-      module construct_at             { private header "__memory/construct_at.h"             }
-      module pointer_traits           { private header "__memory/pointer_traits.h"           }
-      module raw_storage_iterator     { private header "__memory/raw_storage_iterator.h"     }
-      module shared_ptr               { private header "__memory/shared_ptr.h"               }
-      module temporary_buffer         { private header "__memory/temporary_buffer.h"         }
-      module uninitialized_algorithms { private header "__memory/uninitialized_algorithms.h" }
-      module unique_ptr               { private header "__memory/unique_ptr.h"               }
-      module uses_allocator           { private header "__memory/uses_allocator.h"           }
+      module addressof                      { private header "__memory/addressof.h" }
+      module allocation_guard               { private header "__memory/allocation_guard.h"}
+      module allocator                      { private header "__memory/allocator.h" }
+      module allocator_arg_t                { private header "__memory/allocator_arg_t.h" }
+      module allocator_traits               { private header "__memory/allocator_traits.h" }
+      module auto_ptr                       { private header "__memory/auto_ptr.h" }
+      module compressed_pair                { private header "__memory/compressed_pair.h" }
+      module construct_at                   { private header "__memory/construct_at.h" }
+      module is_allocator                   { private header "__memory/is_allocator.h" }
+      module noexcept_move_assign_container { private header "__memory/noexcept_move_assign_container.h" }
+      module pointer_traits                 { private header "__memory/pointer_traits.h" }
+      module raw_storage_iterator           { private header "__memory/raw_storage_iterator.h" }
+      module shared_ptr                     { private header "__memory/shared_ptr.h" }
+      module swap_allocator                 { private header "__memory/swap_allocator.h" }
+      module temp_value                     { private header "__memory/temp_value.h" }
+      module temporary_buffer               { private header "__memory/temporary_buffer.h" }
+      module uninitialized_algorithms       { private header "__memory/uninitialized_algorithms.h" }
+      module unique_ptr                     { private header "__memory/unique_ptr.h" }
+      module uses_allocator                 { private header "__memory/uses_allocator.h" }
     }
   }
   module mutex {
     header "mutex"
     export *
   }
   module new {
     header "new"
module variant {
     module __variant {
       module monostate { private header "__variant/monostate.h" }
     }
   }
   module vector {
     header "vector"
     export initializer_list
     export *
+
+    module __vector {
+      module construct { private header "__vector/construct.h" }
+    }
   }
   module version {
     header "version"
     export *
   }
 
   // __config not modularised due to a bug in Clang
   // FIXME: These should be private.

libcxx/include/set

 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__iterator/iterator_traits.h>
+#include <__memory/is_allocator.h>
 #include <__node_handle>
 #include <__tree>
 #include <__utility/forward.h>
 #include <compare>
 #include <functional>
 #include <initializer_list>
 #include <iterator> // __libcpp_erase_if_container
 #include <version>

libcxx/include/stack

template <class T, class Container>
   void swap(stack<T, Container>& x, stack<T, Container>& y)
   noexcept(noexcept(x.swap(y)));
 
 }  // std
 
 */
 
 #include <__config>
+#include <__memory/is_allocator.h>
 #include <__memory/uses_allocator.h>
 #include <__utility/forward.h>
 #include <deque>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 

libcxx/include/string

 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional_base>
 #include <__iterator/wrap_iter.h>
+#include <__memory/is_allocator.h>
+#include <__memory/noexcept_move_assign_container.h>
+#include <__memory/swap_allocator.h>
 #include <algorithm>
 #include <compare>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd>
 #include <iterator>

libcxx/include/unordered_map

 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__iterator/iterator_traits.h>
 #include <__hash_table>
+#include <__memory/is_allocator.h>
 #include <__node_handle>
 #include <__utility/forward.h>
 #include <compare>
 #include <functional>
 #include <iterator> // __libcpp_erase_if_container
 #include <stdexcept>
 #include <tuple>
 #include <version>

libcxx/include/unordered_set

 }  // std
 
 */
 
 #include <__config>
 #include <__debug>
 #include <__functional/is_transparent.h>
 #include <__hash_table>
+#include <__memory/is_allocator.h>
 #include <__node_handle>
 #include <__utility/forward.h>
 #include <compare>
 #include <functional>
 #include <iterator> // __libcpp_erase_if_container
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/vector

 */
 
 #include <__config>
 #include <__bit_reference>
 #include <__debug>
 #include <__functional_base>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/wrap_iter.h>
+#include <__memory/is_allocator.h>
+#include <__memory/noexcept_move_assign_container.h>
+#include <__memory/swap_allocator.h>
+#include <__memory/temp_value.h>
 #include <__split_buffer>
 #include <__utility/forward.h>
+#include <__vector/construct.h>
 #include <algorithm>
 #include <climits>
 #include <compare>
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd> // for forward declaration of vector
 #include <limits>

libcxx/test/libcxx/diagnostics/detail.headers/algorithm/destruct_n.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__algorithm/destruct_n.h'}}
+#include <__algorithm/destruct_n.h>

libcxx/test/libcxx/diagnostics/detail.headers/functional/builtin_new_allocator.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__functional/builtin_new_allocator.h'}}
+#include <__functional/builtin_new_allocator.h>

libcxx/test/libcxx/diagnostics/detail.headers/memory/is_allocator.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__memory/is_allocator.h'}}
+#include <__memory/is_allocator.h>

libcxx/test/libcxx/diagnostics/detail.headers/memory/noexcept_move_assign_container.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__memory/noexcept_move_assign_container.h'}}
+#include <__memory/noexcept_move_assign_container.h>

libcxx/test/libcxx/diagnostics/detail.headers/memory/swap_allocator.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__memory/swap_allocator.h'}}
+#include <__memory/swap_allocator.h>

libcxx/test/libcxx/diagnostics/detail.headers/memory/temp_value.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__memory/temp_value.h'}}
+#include <__memory/temp_value.h>

libcxx/test/libcxx/diagnostics/detail.headers/vector/construct.module.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__vector/construct.h'}}
+#include <__vector/construct.h>