path: root/contrib/libs/cxxsupp/libcxx/.yandex_meta/licenses.list.txt

====================Apache-2.0====================
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

    1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

    2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

    3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

    4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

    5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

    6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

    7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

    8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

    9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

    END OF TERMS AND CONDITIONS

    APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

    Copyright [yyyy] [name of copyright owner]

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.


====================Apache-2.0 WITH LLVM-exception====================
 * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 * See https://llvm.org/LICENSE.txt for license information.


====================Apache-2.0 WITH LLVM-exception====================
 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception


====================Apache-2.0 WITH LLVM-exception====================
---- LLVM Exceptions to the Apache 2.0 License ----

As an exception, if, as a result of your compiling your source code, portions
of this Software are embedded into an Object form of such source code, you
may redistribute such embedded portions in such Object form without complying
with the conditions of Sections 4(a), 4(b) and 4(d) of the License.

In addition, if you combine or link compiled forms of this Software with
software that is licensed under the GPLv2 ("Combined Software") and if a
court of competent jurisdiction determines that the patent provision (Section
3), the indemnity provision (Section 9) or other Section of the License
conflicts with the conditions of the GPLv2, you may retroactively and
prospectively choose to deem waived or otherwise exclude such Section(s) of
the License, but only in their entirety and only with respect to the Combined
Software.


====================Apache-2.0 WITH LLVM-exception====================
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.


====================Apache-2.0 WITH LLVM-exception====================
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception


====================Apache-2.0 WITH LLVM-exception====================
The LLVM Project is under the Apache License v2.0 with LLVM Exceptions:


====================BSD-2-Clause====================
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.


====================BSD-2-Clause AND MIT====================
2-clause BSD license instead of the MIT/UUIC license that the rest of libc++ is


====================COPYRIGHT====================
 * FreeBSD libc.  These are covered by the following copyright:
 *
 * Copyright (c) 2002-2004 Tim J. Robbins.


====================COPYRIGHT====================
Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT


====================COPYRIGHT====================
Copyright (c) 2009-2019 by the contributors listed in CREDITS.TXT


====================File: CREDITS.TXT==================== 
This file is a partial list of people who have contributed to the LLVM/libc++
project.  If you have contributed a patch or made some other contribution to
LLVM/libc++, please submit a patch to this file to add yourself, and it will be
done!

The list is sorted by surname and formatted to allow easy grepping and
beautification by scripts.  The fields are: name (N), email (E), web-address
(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
(S).

N: Saleem Abdulrasool
E: compnerd@compnerd.org
D: Minor patches and Linux fixes.

N: Dan Albert
E: danalbert@google.com
D: Android support and test runner improvements.

N: Dimitry Andric
E: dimitry@andric.com
D: Visibility fixes, minor FreeBSD portability patches.

N: Holger Arnold
E: holgerar@gmail.com
D: Minor fix.

N: David Chisnall
E: theraven at theravensnest dot org
D: FreeBSD and Solaris ports, libcxxrt support, some atomics work.

N: Marshall Clow
E: mclow.lists@gmail.com
E: marshall@idio.com
D: C++14 support, patches and bug fixes.

N: Jonathan B Coe
E: jbcoe@me.com
D: Implementation of propagate_const.

N: Matthew Dempsky 
E: matthew@dempsky.org 
D: Minor patches and bug fixes. 
 
N: Christopher Di Bella
E: cjdb@google.com
E: cjdb.ns@gmail.com
D: Library concepts.

N: Glen Joseph Fernandes
E: glenjofe@gmail.com
D: Implementation of to_address.

N: Eric Fiselier
E: eric@efcs.ca
D: LFTS support, patches and bug fixes.

N: Bill Fisher
E: william.w.fisher@gmail.com
D: Regex bug fixes.

N: Google Inc.
D: Copyright owner and contributor of the CityHash algorithm

N: Howard Hinnant
E: hhinnant@apple.com
D: Architect and primary author of libc++

N: Sergej Jaskiewicz
E: jaskiewiczs@icloud.com
D: Minor improvements in the testing infrastructure

N: Hyeon-bin Jeong
E: tuhertz@gmail.com
D: Minor patches and bug fixes.

N: Argyrios Kyrtzidis
E: kyrtzidis@apple.com
D: Bug fixes.

N: Bruce Mitchener, Jr.
E: bruce.mitchener@gmail.com
D: Emscripten-related changes.

N: Michel Morin
E: mimomorin@gmail.com
D: Minor patches to is_convertible.

N: Andrew Morrow
E: andrew.c.morrow@gmail.com
D: Minor patches and Linux fixes.

N: Michael Park
E: mcypark@gmail.com
D: Implementation of <variant>.

N: Arvid Picciani
E: aep at exys dot org
D: Minor patches and musl port.

N: Bjorn Reese
E: breese@users.sourceforge.net
D: Initial regex prototype

N: Nico Rieck
E: nico.rieck@gmail.com
D: Windows fixes

N: Jon Roelofs
E: jroelofS@jroelofs.com
D: Remote testing, Newlib port, baremetal/single-threaded support.

N: Kent Ross 
E: k@mad.cash 
D: Patches for operator<=> support 
 
N: Jonathan Sauer
D: Minor patches, mostly related to constexpr

N: Craig Silverstein
E: csilvers@google.com
D: Implemented Cityhash as the string hash function on 64-bit machines

N: Richard Smith
D: Minor patches.

N: Joerg Sonnenberger
E: joerg@NetBSD.org
D: NetBSD port.

N: Stephan Tolksdorf
E: st@quanttec.com
D: Minor <atomic> fix

N: Ruben Van Boxem 
E: vanboxem dot ruben at gmail dot com 
D: Initial Windows patches. 
 
N: Michael van der Westhuizen
E: r1mikey at gmail dot com

N: Larisse Voufo
D: Minor patches.

N: Klaas de Vries
E: klaas at klaasgaaf dot nl
D: Minor bug fix.

N: Zhang Xiongpang
E: zhangxiongpang@gmail.com
D: Minor patches and bug fixes.

N: Xing Xue
E: xingxue@ca.ibm.com
D: AIX port

N: Jeffrey Yasskin
E: jyasskin@gmail.com
E: jyasskin@google.com
D: Linux fixes.

N: Zhihao Yuan 
E: lichray@gmail.com 
D: Standard compatibility fixes. 

 
====================File: import==================== 
#!/bin/sh -e

rev=1e628d0c 
output_dir="libcxx-r$rev"
if [ -z $1 ] ; then
    git clone https://github.com/llvm/llvm-project.git --no-checkout "$output_dir/tmp"
else
    git clone --local --no-checkout $1 "$output_dir/tmp"
fi
cd "$output_dir/tmp"
git checkout "$rev"
cp -R libcxx/include ../include
cp -R libcxx/src ../src
cp libcxx/.clang-format ../.clang-format
cp libcxx/CREDITS.TXT ../CREDITS.TXT
cp libcxx/LICENSE.TXT ../LICENSE.TXT
cd ..
rm -rf tmp
rm src/CMakeLists.txt include/CMakeLists.txt

# Fix tabs and trailing spaces
find -type f | xargs sed -e 's/\t/    /g' -e 's/ *$//' -i


====================File: include/any==================== 
// -*- C++ -*-
//===------------------------------ any -----------------------------------===// 
// 
// 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_ANY 
#define _LIBCPP_ANY 
 
/* 
   any synopsis 
 
namespace std { 
 
  class bad_any_cast : public bad_cast 
  { 
  public: 
    virtual const char* what() const noexcept; 
  }; 
 
  class any 
  { 
  public: 
 
    // 6.3.1 any construct/destruct 
    any() noexcept; 
 
    any(const any& other); 
    any(any&& other) noexcept; 
 
    template <class ValueType> 
      any(ValueType&& value); 
 
    ~any(); 
 
    // 6.3.2 any assignments 
    any& operator=(const any& rhs); 
    any& operator=(any&& rhs) noexcept; 
 
    template <class ValueType> 
      any& operator=(ValueType&& rhs); 
 
    // 6.3.3 any modifiers 
    template <class ValueType, class... Args> 
      decay_t<ValueType>& emplace(Args&&... args); 
    template <class ValueType, class U, class... Args> 
      decay_t<ValueType>& emplace(initializer_list<U>, Args&&...); 
    void reset() noexcept; 
    void swap(any& rhs) noexcept; 
 
    // 6.3.4 any observers 
    bool has_value() const noexcept; 
    const type_info& type() const noexcept; 
  }; 
 
   // 6.4 Non-member functions 
  void swap(any& x, any& y) noexcept; 
 
  template <class T, class ...Args> 
    any make_any(Args&& ...args); 
  template <class T, class U, class ...Args> 
    any make_any(initializer_list<U>, Args&& ...args); 
 
  template<class ValueType> 
    ValueType any_cast(const any& operand); 
  template<class ValueType> 
    ValueType any_cast(any& operand); 
  template<class ValueType> 
    ValueType any_cast(any&& operand); 
 
  template<class ValueType> 
    const ValueType* any_cast(const any* operand) noexcept; 
  template<class ValueType> 
    ValueType* any_cast(any* operand) noexcept; 
 
} // namespace std 
 
*/ 
 
#include <__availability> 
#include <__config> 
#include <__utility/forward.h> 
#include <cstdlib> 
#include <memory> 
#include <type_traits> 
#include <typeinfo> 
#include <version> 
 
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
#pragma GCC system_header 
#endif 
 
namespace std { 
class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast 
{ 
public: 
    virtual const char* what() const _NOEXCEPT; 
}; 
} // namespace std 
 
_LIBCPP_BEGIN_NAMESPACE_STD 
 
#if _LIBCPP_STD_VER > 14 
 
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY 
_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST 
void __throw_bad_any_cast() 
{ 
#ifndef _LIBCPP_NO_EXCEPTIONS 
    throw bad_any_cast(); 
#else 
    _VSTD::abort(); 
#endif 
} 
 
// Forward declarations 
class _LIBCPP_TEMPLATE_VIS any; 
 
template <class _ValueType> 
_LIBCPP_INLINE_VISIBILITY 
add_pointer_t<add_const_t<_ValueType>> 
any_cast(any const *) _NOEXCEPT; 
 
template <class _ValueType> 
_LIBCPP_INLINE_VISIBILITY 
add_pointer_t<_ValueType> any_cast(any *) _NOEXCEPT; 
 
namespace __any_imp 
{ 
  using _Buffer = aligned_storage_t<3*sizeof(void*), alignment_of<void*>::value>; 
 
  template <class _Tp> 
  using _IsSmallObject = integral_constant<bool 
        , sizeof(_Tp) <= sizeof(_Buffer) 
          && alignment_of<_Buffer>::value 
             % alignment_of<_Tp>::value == 0 
          && is_nothrow_move_constructible<_Tp>::value 
        >; 
 
  enum class _Action { 
    _Destroy, 
    _Copy, 
    _Move, 
    _Get, 
    _TypeInfo 
  }; 
 
  template <class _Tp> struct _SmallHandler; 
  template <class _Tp> struct _LargeHandler; 
 
  template <class _Tp> 
  struct  _LIBCPP_TEMPLATE_VIS __unique_typeinfo { static constexpr int __id = 0; }; 
  template <class _Tp> constexpr int __unique_typeinfo<_Tp>::__id; 
 
  template <class _Tp> 
  inline _LIBCPP_INLINE_VISIBILITY 
  constexpr const void* __get_fallback_typeid() { 
      return &__unique_typeinfo<remove_cv_t<remove_reference_t<_Tp>>>::__id; 
  } 
 
  template <class _Tp> 
  inline _LIBCPP_INLINE_VISIBILITY 
  bool __compare_typeid(type_info const* __id, const void* __fallback_id) 
  { 
#if !defined(_LIBCPP_NO_RTTI) 
      if (__id && *__id == typeid(_Tp)) 
          return true; 
#endif 
      if (!__id && __fallback_id == __any_imp::__get_fallback_typeid<_Tp>()) 
          return true; 
      return false; 
  } 
 
  template <class _Tp> 
  using _Handler = conditional_t< 
    _IsSmallObject<_Tp>::value, _SmallHandler<_Tp>, _LargeHandler<_Tp>>; 
 
} // namespace __any_imp 
 
class _LIBCPP_TEMPLATE_VIS any 
{ 
public: 
  // construct/destruct 
  _LIBCPP_INLINE_VISIBILITY 
  constexpr any() _NOEXCEPT : __h(nullptr) {} 
 
  _LIBCPP_INLINE_VISIBILITY 
  any(any const & __other) : __h(nullptr) 
  { 
    if (__other.__h) __other.__call(_Action::_Copy, this); 
  } 
 
  _LIBCPP_INLINE_VISIBILITY 
  any(any && __other) _NOEXCEPT : __h(nullptr) 
  { 
    if (__other.__h) __other.__call(_Action::_Move, this); 
  } 
 
  template < 
      class _ValueType 
    , class _Tp = decay_t<_ValueType> 
    , class = enable_if_t< 
        !is_same<_Tp, any>::value && 
        !__is_inplace_type<_ValueType>::value && 
        is_copy_constructible<_Tp>::value> 
    > 
  _LIBCPP_INLINE_VISIBILITY 
  any(_ValueType && __value); 
 
  template <class _ValueType, class ..._Args, 
    class _Tp = decay_t<_ValueType>, 
    class = enable_if_t< 
        is_constructible<_Tp, _Args...>::value && 
        is_copy_constructible<_Tp>::value 
    > 
  > 
  _LIBCPP_INLINE_VISIBILITY 
  explicit any(in_place_type_t<_ValueType>, _Args&&... __args); 
 
  template <class _ValueType, class _Up, class ..._Args, 
    class _Tp = decay_t<_ValueType>, 
    class = enable_if_t< 
        is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value && 
        is_copy_constructible<_Tp>::value> 
  > 
  _LIBCPP_INLINE_VISIBILITY 
  explicit any(in_place_type_t<_ValueType>, initializer_list<_Up>, _Args&&... __args); 
 
  _LIBCPP_INLINE_VISIBILITY 
  ~any() { this->reset(); } 
 
  // assignments 
  _LIBCPP_INLINE_VISIBILITY 
  any & operator=(any const & __rhs) { 
    any(__rhs).swap(*this); 
    return *this; 
  } 
 
  _LIBCPP_INLINE_VISIBILITY 
  any & operator=(any && __rhs) _NOEXCEPT { 
    any(_VSTD::move(__rhs)).swap(*this); 
    return *this; 
  } 
 
  template < 
      class _ValueType 
    , class _Tp = decay_t<_ValueType> 
    , class = enable_if_t< 
          !is_same<_Tp, any>::value 
          && is_copy_constructible<_Tp>::value> 
    > 
  _LIBCPP_INLINE_VISIBILITY 
  any & operator=(_ValueType && __rhs); 
 
  template <class _ValueType, class ..._Args, 
    class _Tp = decay_t<_ValueType>, 
    class = enable_if_t< 
        is_constructible<_Tp, _Args...>::value && 
        is_copy_constructible<_Tp>::value> 
    > 
  _LIBCPP_INLINE_VISIBILITY 
  _Tp& emplace(_Args&&... args); 
 
  template <class _ValueType, class _Up, class ..._Args, 
    class _Tp = decay_t<_ValueType>, 
    class = enable_if_t< 
        is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value && 
        is_copy_constructible<_Tp>::value> 
  > 
  _LIBCPP_INLINE_VISIBILITY 
  _Tp& emplace(initializer_list<_Up>, _Args&&...); 
 
  // 6.3.3 any modifiers 
  _LIBCPP_INLINE_VISIBILITY 
  void reset() _NOEXCEPT { if (__h) this->__call(_Action::_Destroy); } 
 
  _LIBCPP_INLINE_VISIBILITY 
  void swap(any & __rhs) _NOEXCEPT; 
 
  // 6.3.4 any observers 
  _LIBCPP_INLINE_VISIBILITY 
  bool has_value() const _NOEXCEPT { return __h != nullptr; } 
 
#if !defined(_LIBCPP_NO_RTTI) 
  _LIBCPP_INLINE_VISIBILITY 
  const type_info & type() const _NOEXCEPT { 
    if (__h) { 
        return *static_cast<type_info const *>(this->__call(_Action::_TypeInfo)); 
    } else { 
        return typeid(void); 
    } 
  } 
#endif 
 
private: 
    typedef __any_imp::_Action _Action; 
    using _HandleFuncPtr =  void* (*)(_Action, any const *, any *, const type_info *, 
      const void* __fallback_info); 
 
    union _Storage { 
        constexpr _Storage() : __ptr(nullptr) {} 
        void *  __ptr; 
        __any_imp::_Buffer __buf; 
    }; 
 
    _LIBCPP_INLINE_VISIBILITY 
    void * __call(_Action __a, any * __other = nullptr, 
                  type_info const * __info = nullptr, 
                   const void* __fallback_info = nullptr) const 
    { 
        return __h(__a, this, __other, __info, __fallback_info); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    void * __call(_Action __a, any * __other = nullptr, 
                  type_info const * __info = nullptr, 
                  const void* __fallback_info = nullptr) 
    { 
        return __h(__a, this, __other, __info, __fallback_info); 
    } 
 
    template <class> 
    friend struct __any_imp::_SmallHandler; 
    template <class> 
    friend struct __any_imp::_LargeHandler; 
 
    template <class _ValueType> 
    friend add_pointer_t<add_const_t<_ValueType>> 
    any_cast(any const *) _NOEXCEPT; 
 
    template <class _ValueType> 
    friend add_pointer_t<_ValueType> 
    any_cast(any *) _NOEXCEPT; 
 
    _HandleFuncPtr __h = nullptr; 
    _Storage __s; 
}; 
 
namespace __any_imp 
{ 
  template <class _Tp> 
  struct _LIBCPP_TEMPLATE_VIS _SmallHandler 
  { 
     _LIBCPP_INLINE_VISIBILITY 
     static void* __handle(_Action __act, any const * __this, any * __other, 
                           type_info const * __info, const void* __fallback_info) 
     { 
        switch (__act) 
        { 
        case _Action::_Destroy: 
          __destroy(const_cast<any &>(*__this)); 
          return nullptr; 
        case _Action::_Copy: 
            __copy(*__this, *__other); 
            return nullptr; 
        case _Action::_Move: 
          __move(const_cast<any &>(*__this), *__other); 
          return nullptr; 
        case _Action::_Get: 
            return __get(const_cast<any &>(*__this), __info, __fallback_info); 
        case _Action::_TypeInfo: 
          return __type_info(); 
        } 
    } 
 
    template <class ..._Args> 
    _LIBCPP_INLINE_VISIBILITY 
    static _Tp& __create(any & __dest, _Args&&... __args) { 
        typedef allocator<_Tp> _Alloc; 
        typedef allocator_traits<_Alloc> _ATraits; 
        _Alloc __a; 
        _Tp * __ret = static_cast<_Tp*>(static_cast<void*>(&__dest.__s.__buf)); 
        _ATraits::construct(__a, __ret, _VSTD::forward<_Args>(__args)...); 
        __dest.__h = &_SmallHandler::__handle; 
        return *__ret; 
    } 
 
  private: 
    _LIBCPP_INLINE_VISIBILITY 
    static void __destroy(any & __this) { 
        typedef allocator<_Tp> _Alloc; 
        typedef allocator_traits<_Alloc> _ATraits; 
        _Alloc __a; 
        _Tp * __p = static_cast<_Tp *>(static_cast<void*>(&__this.__s.__buf)); 
        _ATraits::destroy(__a, __p); 
        __this.__h = nullptr; 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    static void __copy(any const & __this, any & __dest) { 
        _SmallHandler::__create(__dest, *static_cast<_Tp const *>( 
            static_cast<void const *>(&__this.__s.__buf))); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    static void __move(any & __this, any & __dest) { 
        _SmallHandler::__create(__dest, _VSTD::move( 
            *static_cast<_Tp*>(static_cast<void*>(&__this.__s.__buf)))); 
        __destroy(__this); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    static void* __get(any & __this, 
                       type_info const * __info, 
                       const void* __fallback_id) 
    { 
        if (__any_imp::__compare_typeid<_Tp>(__info, __fallback_id)) 
            return static_cast<void*>(&__this.__s.__buf); 
        return nullptr; 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    static void* __type_info() 
    { 
#if !defined(_LIBCPP_NO_RTTI) 
        return const_cast<void*>(static_cast<void const *>(&typeid(_Tp))); 
#else 
        return nullptr; 
#endif 
    } 
  }; 
 
  template <class _Tp> 
  struct _LIBCPP_TEMPLATE_VIS _LargeHandler 
  { 
    _LIBCPP_INLINE_VISIBILITY 
    static void* __handle(_Action __act, any const * __this, 
                          any * __other, type_info const * __info, 
                          void const* __fallback_info) 
    { 
        switch (__act) 
        { 
        case _Action::_Destroy: 
          __destroy(const_cast<any &>(*__this)); 
          return nullptr; 
        case _Action::_Copy: 
          __copy(*__this, *__other); 
          return nullptr; 
        case _Action::_Move: 
          __move(const_cast<any &>(*__this), *__other); 
          return nullptr; 
        case _Action::_Get: 
            return __get(const_cast<any &>(*__this), __info, __fallback_info); 
        case _Action::_TypeInfo: 
          return __type_info(); 
        } 
    } 
 
    template <class ..._Args> 
    _LIBCPP_INLINE_VISIBILITY 
    static _Tp& __create(any & __dest, _Args&&... __args) { 
        typedef allocator<_Tp> _Alloc; 
        typedef allocator_traits<_Alloc> _ATraits; 
        typedef __allocator_destructor<_Alloc> _Dp; 
        _Alloc __a; 
        unique_ptr<_Tp, _Dp> __hold(_ATraits::allocate(__a, 1), _Dp(__a, 1)); 
        _Tp * __ret = __hold.get(); 
        _ATraits::construct(__a, __ret, _VSTD::forward<_Args>(__args)...); 
        __dest.__s.__ptr = __hold.release(); 
        __dest.__h = &_LargeHandler::__handle; 
        return *__ret; 
    } 
 
  private: 
 
    _LIBCPP_INLINE_VISIBILITY 
    static void __destroy(any & __this){ 
        typedef allocator<_Tp> _Alloc; 
        typedef allocator_traits<_Alloc> _ATraits; 
        _Alloc __a; 
        _Tp * __p = static_cast<_Tp *>(__this.__s.__ptr); 
        _ATraits::destroy(__a, __p); 
        _ATraits::deallocate(__a, __p, 1); 
        __this.__h = nullptr; 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    static void __copy(any const & __this, any & __dest) { 
        _LargeHandler::__create(__dest, *static_cast<_Tp const *>(__this.__s.__ptr)); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    static void __move(any & __this, any & __dest) { 
      __dest.__s.__ptr = __this.__s.__ptr; 
      __dest.__h = &_LargeHandler::__handle; 
      __this.__h = nullptr; 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    static void* __get(any & __this, type_info const * __info, 
                       void const* __fallback_info) 
    { 
        if (__any_imp::__compare_typeid<_Tp>(__info, __fallback_info)) 
            return static_cast<void*>(__this.__s.__ptr); 
        return nullptr; 
 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    static void* __type_info() 
    { 
#if !defined(_LIBCPP_NO_RTTI) 
        return const_cast<void*>(static_cast<void const *>(&typeid(_Tp))); 
#else 
        return nullptr; 
#endif 
    } 
  }; 
 
} // namespace __any_imp 
 
 
template <class _ValueType, class _Tp, class> 
any::any(_ValueType && __v) : __h(nullptr) 
{ 
  __any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_ValueType>(__v)); 
} 
 
template <class _ValueType, class ..._Args, class _Tp, class> 
any::any(in_place_type_t<_ValueType>, _Args&&... __args) { 
  __any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_Args>(__args)...); 
} 
 
template <class _ValueType, class _Up, class ..._Args, class _Tp, class> 
any::any(in_place_type_t<_ValueType>, initializer_list<_Up> __il, _Args&&... __args) { 
  __any_imp::_Handler<_Tp>::__create(*this, __il, _VSTD::forward<_Args>(__args)...); 
} 
 
template <class _ValueType, class, class> 
inline _LIBCPP_INLINE_VISIBILITY 
any & any::operator=(_ValueType && __v) 
{ 
  any(_VSTD::forward<_ValueType>(__v)).swap(*this); 
  return *this; 
} 
 
template <class _ValueType, class ..._Args, class _Tp, class> 
inline _LIBCPP_INLINE_VISIBILITY 
_Tp& any::emplace(_Args&&... __args) { 
  reset(); 
  return __any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_Args>(__args)...); 
} 
 
template <class _ValueType, class _Up, class ..._Args, class _Tp, class> 
inline _LIBCPP_INLINE_VISIBILITY 
_Tp& any::emplace(initializer_list<_Up> __il, _Args&&... __args) { 
  reset(); 
  return __any_imp::_Handler<_Tp>::__create(*this, __il, _VSTD::forward<_Args>(__args)...); 
} 
 
inline _LIBCPP_INLINE_VISIBILITY 
void any::swap(any & __rhs) _NOEXCEPT 
{ 
    if (this == &__rhs) 
      return; 
    if (__h && __rhs.__h) { 
        any __tmp; 
        __rhs.__call(_Action::_Move, &__tmp); 
        this->__call(_Action::_Move, &__rhs); 
        __tmp.__call(_Action::_Move, this); 
    } 
    else if (__h) { 
        this->__call(_Action::_Move, &__rhs); 
    } 
    else if (__rhs.__h) { 
        __rhs.__call(_Action::_Move, this); 
    } 
} 
 
// 6.4 Non-member functions 
 
inline _LIBCPP_INLINE_VISIBILITY 
void swap(any & __lhs, any & __rhs) _NOEXCEPT 
{ 
    __lhs.swap(__rhs); 
} 
 
template <class _Tp, class ..._Args> 
inline _LIBCPP_INLINE_VISIBILITY 
any make_any(_Args&&... __args) { 
    return any(in_place_type<_Tp>, _VSTD::forward<_Args>(__args)...); 
} 
 
template <class _Tp, class _Up, class ..._Args> 
inline _LIBCPP_INLINE_VISIBILITY 
any make_any(initializer_list<_Up> __il, _Args&&... __args) { 
    return any(in_place_type<_Tp>, __il, _VSTD::forward<_Args>(__args)...); 
} 
 
template <class _ValueType> 
inline _LIBCPP_INLINE_VISIBILITY 
_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST 
_ValueType any_cast(any const & __v) 
{ 
    using _RawValueType = __uncvref_t<_ValueType>; 
    static_assert(is_constructible<_ValueType, _RawValueType const &>::value, 
                  "ValueType is required to be a const lvalue reference " 
                  "or a CopyConstructible type"); 
    auto __tmp = _VSTD::any_cast<add_const_t<_RawValueType>>(&__v); 
    if (__tmp == nullptr) 
        __throw_bad_any_cast(); 
    return static_cast<_ValueType>(*__tmp); 
} 
 
template <class _ValueType> 
inline _LIBCPP_INLINE_VISIBILITY 
_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST 
_ValueType any_cast(any & __v) 
{ 
    using _RawValueType = __uncvref_t<_ValueType>; 
    static_assert(is_constructible<_ValueType, _RawValueType &>::value, 
                  "ValueType is required to be an lvalue reference " 
                  "or a CopyConstructible type"); 
    auto __tmp = _VSTD::any_cast<_RawValueType>(&__v); 
    if (__tmp == nullptr) 
        __throw_bad_any_cast(); 
    return static_cast<_ValueType>(*__tmp); 
} 
 
template <class _ValueType> 
inline _LIBCPP_INLINE_VISIBILITY 
_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST 
_ValueType any_cast(any && __v) 
{ 
    using _RawValueType = __uncvref_t<_ValueType>; 
    static_assert(is_constructible<_ValueType, _RawValueType>::value, 
                  "ValueType is required to be an rvalue reference " 
                  "or a CopyConstructible type"); 
    auto __tmp = _VSTD::any_cast<_RawValueType>(&__v); 
    if (__tmp == nullptr) 
        __throw_bad_any_cast(); 
    return static_cast<_ValueType>(_VSTD::move(*__tmp)); 
} 
 
template <class _ValueType> 
inline _LIBCPP_INLINE_VISIBILITY 
add_pointer_t<add_const_t<_ValueType>> 
any_cast(any const * __any) _NOEXCEPT 
{ 
    static_assert(!is_reference<_ValueType>::value, 
                  "_ValueType may not be a reference."); 
    return _VSTD::any_cast<_ValueType>(const_cast<any *>(__any)); 
} 
 
template <class _RetType> 
inline _LIBCPP_INLINE_VISIBILITY 
_RetType __pointer_or_func_cast(void* __p, /*IsFunction*/false_type) noexcept { 
  return static_cast<_RetType>(__p); 
} 
 
template <class _RetType> 
inline _LIBCPP_INLINE_VISIBILITY 
_RetType __pointer_or_func_cast(void*, /*IsFunction*/true_type) noexcept { 
  return nullptr; 
} 
 
template <class _ValueType> 
add_pointer_t<_ValueType> 
any_cast(any * __any) _NOEXCEPT 
{ 
    using __any_imp::_Action; 
    static_assert(!is_reference<_ValueType>::value, 
                  "_ValueType may not be a reference."); 
    typedef typename add_pointer<_ValueType>::type _ReturnType; 
    if (__any && __any->__h) { 
      void *__p = __any->__call(_Action::_Get, nullptr, 
#if !defined(_LIBCPP_NO_RTTI) 
                          &typeid(_ValueType), 
#else 
                          nullptr, 
#endif 
                          __any_imp::__get_fallback_typeid<_ValueType>()); 
        return _VSTD::__pointer_or_func_cast<_ReturnType>( 
            __p, is_function<_ValueType>{}); 
    } 
    return nullptr; 
} 
 
#endif // _LIBCPP_STD_VER > 14 
 
_LIBCPP_END_NAMESPACE_STD 
 
#endif // _LIBCPP_ANY 
 
 
====================File: include/exception==================== 
// -*- C++ -*- 
//===-------------------------- exception ---------------------------------===//
//
// 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_EXCEPTION
#define _LIBCPP_EXCEPTION

/*
    exception synopsis

namespace std
{

class exception
{
public:
    exception() noexcept;
    exception(const exception&) noexcept;
    exception& operator=(const exception&) noexcept;
    virtual ~exception() noexcept;
    virtual const char* what() const noexcept;
};

class bad_exception
    : public exception
{
public:
    bad_exception() noexcept;
    bad_exception(const bad_exception&) noexcept;
    bad_exception& operator=(const bad_exception&) noexcept;
    virtual ~bad_exception() noexcept;
    virtual const char* what() const noexcept;
};

typedef void (*unexpected_handler)();
unexpected_handler set_unexpected(unexpected_handler  f ) noexcept;
unexpected_handler get_unexpected() noexcept;
[[noreturn]] void unexpected();

typedef void (*terminate_handler)();
terminate_handler set_terminate(terminate_handler  f ) noexcept;
terminate_handler get_terminate() noexcept;
[[noreturn]] void terminate() noexcept;

bool uncaught_exception()  noexcept;
int  uncaught_exceptions() noexcept;  // C++17

typedef unspecified exception_ptr;

exception_ptr current_exception() noexcept;
void rethrow_exception [[noreturn]] (exception_ptr p);
template<class E> exception_ptr make_exception_ptr(E e) noexcept;

class nested_exception
{
public:
    nested_exception() noexcept;
    nested_exception(const nested_exception&) noexcept = default;
    nested_exception& operator=(const nested_exception&) noexcept = default;
    virtual ~nested_exception() = default;

    // access functions
    [[noreturn]] void rethrow_nested() const;
    exception_ptr nested_ptr() const noexcept;
};

template <class T> [[noreturn]] void throw_with_nested(T&& t);
template <class E> void rethrow_if_nested(const E& e);

}  // std

*/

#include <__availability> 
#include <__config>
#include <__memory/addressof.h> 
#include <cstddef>
#include <cstdlib>
#include <type_traits>
#include <version>

#if defined(_LIBCPP_ABI_VCRUNTIME)
#include <vcruntime_exception.h>
#endif

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif

namespace std  // purposefully not using versioning namespace
{

#if !defined(_LIBCPP_ABI_VCRUNTIME)
class _LIBCPP_EXCEPTION_ABI exception
{
public:
    _LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}
    _LIBCPP_INLINE_VISIBILITY exception(const exception&) _NOEXCEPT = default;

    virtual ~exception() _NOEXCEPT;
    virtual const char* what() const _NOEXCEPT;
};

class _LIBCPP_EXCEPTION_ABI bad_exception
    : public exception
{
public:
    _LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {}
    virtual ~bad_exception() _NOEXCEPT;
    virtual const char* what() const _NOEXCEPT;
};
#endif // !_LIBCPP_ABI_VCRUNTIME

#if _LIBCPP_STD_VER <= 14 \
    || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS) \
    || defined(_LIBCPP_BUILDING_LIBRARY)
typedef void (*unexpected_handler)();
_LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
_LIBCPP_FUNC_VIS unexpected_handler get_unexpected() _NOEXCEPT;
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void unexpected();
#endif

typedef void (*terminate_handler)();
_LIBCPP_FUNC_VIS terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
_LIBCPP_FUNC_VIS terminate_handler get_terminate() _NOEXCEPT;
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void terminate() _NOEXCEPT;

_LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT;
_LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS int uncaught_exceptions() _NOEXCEPT;

class _LIBCPP_TYPE_VIS exception_ptr;

_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);

class _LIBCPP_TYPE_VIS exception_ptr
{
    void* __ptr_;
public:
    _LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {}
    _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}

    exception_ptr(const exception_ptr&) _NOEXCEPT;
    exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
    ~exception_ptr() _NOEXCEPT;

    _LIBCPP_INLINE_VISIBILITY explicit operator bool() const _NOEXCEPT 
    {return __ptr_ != nullptr;}

    friend _LIBCPP_INLINE_VISIBILITY
    bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
        {return __x.__ptr_ == __y.__ptr_;}

    friend _LIBCPP_INLINE_VISIBILITY
    bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
        {return !(__x == __y);}

    friend _LIBCPP_FUNC_VIS void swap(exception_ptr& __x, exception_ptr& __y) _NOEXCEPT
    {
        void* __tmp = __x.__ptr_;
        __x.__ptr_ = __y.__ptr_;
        __y.__ptr_ = __tmp;
    }

    friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
    friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
};

#ifndef _LIBCPP_ABI_MICROSOFT

template<class _Ep>
_LIBCPP_INLINE_VISIBILITY exception_ptr
make_exception_ptr(_Ep __e) _NOEXCEPT
{
#ifndef _LIBCPP_NO_EXCEPTIONS
    try
    {
        throw __e;
    }
    catch (...)
    {
        return current_exception();
    }
#else
    ((void)__e);
    _VSTD::abort();
#endif
}

#else // _LIBCPP_ABI_MICROSOFT

_LIBCPP_FUNC_VIS exception_ptr __copy_exception_ptr(void *__exception, const void* __ptr);

// This is a built-in template function which automagically extracts the required
// information.
template <class _E> void *__GetExceptionInfo(_E);

template<class _Ep>
exception_ptr
make_exception_ptr(_Ep __e) _NOEXCEPT
{
  return __copy_exception_ptr(_VSTD::addressof(__e), __GetExceptionInfo(__e));
}

#endif // _LIBCPP_ABI_MICROSOFT
// nested_exception

class _LIBCPP_EXCEPTION_ABI nested_exception
{
    exception_ptr __ptr_;
public:
    nested_exception() _NOEXCEPT;
//     nested_exception(const nested_exception&) noexcept = default;
//     nested_exception& operator=(const nested_exception&) noexcept = default;
    virtual ~nested_exception() _NOEXCEPT;

    // access functions
    _LIBCPP_NORETURN void rethrow_nested() const;
    _LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const _NOEXCEPT {return __ptr_;}
};

template <class _Tp>
struct __nested
    : public _Tp,
      public nested_exception
{
    _LIBCPP_INLINE_VISIBILITY explicit __nested(const _Tp& __t) : _Tp(__t) {}
};

#ifndef _LIBCPP_NO_EXCEPTIONS
template <class _Tp, class _Up, bool>
struct __throw_with_nested;

template <class _Tp, class _Up>
struct __throw_with_nested<_Tp, _Up, true> {
    _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void
    __do_throw(_Tp&& __t)
    {
        throw __nested<_Up>(static_cast<_Tp&&>(__t)); 
    }
};

template <class _Tp, class _Up>
struct __throw_with_nested<_Tp, _Up, false> {
    _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void
#ifndef _LIBCPP_CXX03_LANG
    __do_throw(_Tp&& __t)
#else
    __do_throw (_Tp& __t)
#endif // _LIBCPP_CXX03_LANG 
    {
        throw static_cast<_Tp&&>(__t); 
    }
};
#endif

template <class _Tp>
_LIBCPP_NORETURN
void
throw_with_nested(_Tp&& __t)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
    typedef typename decay<_Tp>::type _Up;
    static_assert( is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible");
    __throw_with_nested<_Tp, _Up,
        is_class<_Up>::value &&
        !is_base_of<nested_exception, _Up>::value &&
        !__libcpp_is_final<_Up>::value>::
            __do_throw(static_cast<_Tp&&>(__t)); 
#else
    ((void)__t);
    // FIXME: Make this abort
#endif
}

template <class _From, class _To>
struct __can_dynamic_cast : public _LIBCPP_BOOL_CONSTANT(
              is_polymorphic<_From>::value &&
                 (!is_base_of<_To, _From>::value ||
                   is_convertible<const _From*, const _To*>::value)) {};

template <class _Ep>
inline _LIBCPP_INLINE_VISIBILITY
void
rethrow_if_nested(const _Ep& __e,
                  typename enable_if< __can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0)
{
    const nested_exception* __nep = dynamic_cast<const nested_exception*>(_VSTD::addressof(__e));
    if (__nep)
        __nep->rethrow_nested();
}

template <class _Ep>
inline _LIBCPP_INLINE_VISIBILITY
void
rethrow_if_nested(const _Ep&,
                  typename enable_if<!__can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0)
{
}

}  // std

#endif // _LIBCPP_EXCEPTION 


====================File: include/experimental/list==================== 
// -*- C++ -*- 
//===--------------------------- list ------------------------------------===// 
// 
// 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_EXPERIMENTAL_LIST 
#define _LIBCPP_EXPERIMENTAL_LIST 
/* 
    experimental/list synopsis 

// C++1z 
namespace std { 
namespace experimental { 
inline namespace fundamentals_v1 { 
namespace pmr { 

  template <class T> 
  using list = std::list<T,polymorphic_allocator<T>>; 

} // namespace pmr 
} // namespace fundamentals_v1 
} // namespace experimental 
} // namespace std 
 
 */ 
 
#include <experimental/__config> 
#include <list> 
#include <experimental/memory_resource> 
 
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
#pragma GCC system_header 
#endif 
 
_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR 
 
template <class _ValueT> 
using list = _VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>; 
 
_LIBCPP_END_NAMESPACE_LFTS_PMR 
 
#endif /* _LIBCPP_EXPERIMENTAL_LIST */ 
 
 
====================File: include/format==================== 
// -*- C++ -*- 
//===--------------------------- format -----------------------------------===// 
// 
// 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_FORMAT 
#define _LIBCPP_FORMAT 
 
/* 
 
namespace std { 
  // [format.context], class template basic_format_context 
  template<class Out, class charT> 
  class basic_format_context { 
    basic_format_args<basic_format_context> args_;      // exposition only 
    Out out_;                                           // exposition only 
 
  public: 
    using iterator = Out; 
    using char_type = charT; 
    template<class T> using formatter_type = formatter<T, charT>; 
 
    basic_format_arg<basic_format_context> arg(size_t id) const; 
    std::locale locale(); 
 
    iterator out(); 
    void advance_to(iterator it); 
  }; 
  using format_context = basic_format_context<unspecified, char>; 
  using wformat_context = basic_format_context<unspecified, wchar_t>; 
 
  // [format.args], class template basic_format_args 
  template<class Context> 
  class basic_format_args { 
    size_t size_;                               // exposition only 
    const basic_format_arg<Context>* data_;     // exposition only 
 
  public: 
    basic_format_args() noexcept; 
 
    template<class... Args> 
      basic_format_args(const format-arg-store<Context, Args...>& store) noexcept; 
 
    basic_format_arg<Context> get(size_t i) const noexcept; 
  }; 
  using format_args = basic_format_args<format_context>; 
  using wformat_args = basic_format_args<wformat_context>; 
 
 
  template<class Out, class charT> 
    using format_args_t = basic_format_args<basic_format_context<Out, charT>>; 
 
  // [format.functions], formatting functions 
  template<class... Args> 
    string format(string_view fmt, const Args&... args); 
  template<class... Args> 
    wstring format(wstring_view fmt, const Args&... args); 
  template<class... Args> 
    string format(const locale& loc, string_view fmt, const Args&... args); 
  template<class... Args> 
    wstring format(const locale& loc, wstring_view fmt, const Args&... args); 
 
  string vformat(string_view fmt, format_args args); 
  wstring vformat(wstring_view fmt, wformat_args args); 
  string vformat(const locale& loc, string_view fmt, format_args args); 
  wstring vformat(const locale& loc, wstring_view fmt, wformat_args args); 
 
  template<class Out, class... Args> 
    Out format_to(Out out, string_view fmt, const Args&... args); 
  template<class Out, class... Args> 
    Out format_to(Out out, wstring_view fmt, const Args&... args); 
  template<class Out, class... Args> 
    Out format_to(Out out, const locale& loc, string_view fmt, const Args&... args); 
  template<class Out, class... Args> 
    Out format_to(Out out, const locale& loc, wstring_view fmt, const Args&... args); 
 
  template<class Out> 
    Out vformat_to(Out out, string_view fmt, 
                   format_args_t<type_identity_t<Out>, char> args); 
  template<class Out> 
    Out vformat_to(Out out, wstring_view fmt, 
                   format_args_t<type_identity_t<Out>, wchar_t> args); 
  template<class Out> 
    Out vformat_to(Out out, const locale& loc, string_view fmt, 
                   format_args_t<type_identity_t<Out>, char> args); 
  template<class Out> 
    Out vformat_to(Out out, const locale& loc, wstring_view fmt, 
                   format_args_t<type_identity_t<Out>, wchar_t> args); 
 
  template<class Out> struct format_to_n_result { 
    Out out; 
    iter_difference_t<Out> size; 
  }; 
 
 template<class Out, class... Args> 
    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n, 
                                        string_view fmt, const Args&... args); 
  template<class Out, class... Args> 
    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n, 
                                        wstring_view fmt, const Args&... args); 
  template<class Out, class... Args> 
    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n, 
                                        const locale& loc, string_view fmt, 
                                        const Args&... args); 
  template<class Out, class... Args> 
    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n, 
                                        const locale& loc, wstring_view fmt, 
                                        const Args&... args); 
 
  template<class... Args> 
    size_t formatted_size(string_view fmt, const Args&... args); 
  template<class... Args> 
    size_t formatted_size(wstring_view fmt, const Args&... args); 
  template<class... Args> 
    size_t formatted_size(const locale& loc, string_view fmt, const Args&... args); 
  template<class... Args> 
    size_t formatted_size(const locale& loc, wstring_view fmt, const Args&... args); 
 
  // [format.formatter], formatter 
  template<> struct formatter<char, char>; 
  template<> struct formatter<char, wchar_t>; 
  template<> struct formatter<wchar_t, wchar_t>; 
 
  template<> struct formatter<charT*, charT>; 
  template<> struct formatter<const charT*, charT>; 
  template<size_t N> struct formatter<const charT[N], charT>; 
  template<class traits, class Allocator> 
    struct formatter<basic_string<charT, traits, Allocator>, charT>; 
  template<class traits> 
    struct formatter<basic_string_view<charT, traits>, charT>; 
 
  // [format.parse.ctx], class template basic_format_parse_context 
  template<class charT> 
  class basic_format_parse_context { 
  public: 
    using char_type = charT; 
    using const_iterator = typename basic_string_view<charT>::const_iterator; 
    using iterator = const_iterator; 
 
  private: 
    iterator begin_;                                    // exposition only 
    iterator end_;                                      // exposition only 
    enum indexing { unknown, manual, automatic };       // exposition only 
    indexing indexing_;                                 // exposition only 
    size_t next_arg_id_;                                // exposition only 
    size_t num_args_;                                   // exposition only 
 
  public: 
    constexpr explicit basic_format_parse_context(basic_string_view<charT> fmt, 
                                                  size_t num_args = 0) noexcept; 
    basic_format_parse_context(const basic_format_parse_context&) = delete; 
    basic_format_parse_context& operator=(const basic_format_parse_context&) = delete; 
 
    constexpr const_iterator begin() const noexcept; 
    constexpr const_iterator end() const noexcept; 
    constexpr void advance_to(const_iterator it); 
 
    constexpr size_t next_arg_id(); 
    constexpr void check_arg_id(size_t id); 
  }; 
  using format_parse_context = basic_format_parse_context<char>; 
  using wformat_parse_context = basic_format_parse_context<wchar_t>; 
 
  // [format.arguments], arguments 
  // [format.arg], class template basic_format_arg 
  template<class Context> 
  class basic_format_arg { 
  public: 
    class handle; 
 
  private: 
    using char_type = typename Context::char_type;                              // exposition only 
 
    variant<monostate, bool, char_type, 
            int, unsigned int, long long int, unsigned long long int, 
            float, double, long double, 
            const char_type*, basic_string_view<char_type>, 
            const void*, handle> value;                                         // exposition only 
 
    template<class T> explicit basic_format_arg(const T& v) noexcept;           // exposition only 
    explicit basic_format_arg(float n) noexcept;                                // exposition only 
    explicit basic_format_arg(double n) noexcept;                               // exposition only 
    explicit basic_format_arg(long double n) noexcept;                          // exposition only 
    explicit basic_format_arg(const char_type* s);                              // exposition only 
 
    template<class traits> 
      explicit basic_format_arg( 
        basic_string_view<char_type, traits> s) noexcept;                       // exposition only 
 
    template<class traits, class Allocator> 
      explicit basic_format_arg( 
        const basic_string<char_type, traits, Allocator>& s) noexcept;          // exposition only 
 
    explicit basic_format_arg(nullptr_t) noexcept;                              // exposition only 
 
    template<class T> 
      explicit basic_format_arg(const T* p) noexcept;                           // exposition only 
 
  public: 
    basic_format_arg() noexcept; 
 
    explicit operator bool() const noexcept; 
  }; 
 
  template<class Visitor, class Context> 
    see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg); 
 
  // [format.arg.store], class template format-arg-store 
  template<class Context, class... Args> 
  struct format-arg-store {      // exposition only 
    array<basic_format_arg<Context>, sizeof...(Args)> args; 
  }; 
 
  template<class Context = format_context, class... Args> 
    format-arg-store<Context, Args...> 
      make_format_args(const Args&... args); 
  template<class... Args> 
    format-arg-store<wformat_context, Args...> 
      make_wformat_args(const Args&... args); 
 
  // [format.error], class format_error 
  class format_error : public runtime_error { 
  public: 
    explicit format_error(const string& what_arg); 
    explicit format_error(const char* what_arg); 
  }; 
 
  // [format.parse.ctx], class template basic_format_parse_context 
  template<class charT> 
  class basic_format_parse_context { 
  public: 
    using char_type = charT; 
    using const_iterator = typename basic_string_view<charT>::const_iterator; 
    using iterator = const_iterator; 
 
  private: 
    iterator begin_;                                    // exposition only 
    iterator end_;                                      // exposition only 
    enum indexing { unknown, manual, automatic };       // exposition only 
    indexing indexing_;                                 // exposition only 
    size_t next_arg_id_;                                // exposition only 
    size_t num_args_;                                   // exposition only 
 
  public: 
    constexpr explicit basic_format_parse_context(basic_string_view<charT> fmt, 
                                                  size_t num_args = 0) noexcept; 
    basic_format_parse_context(const basic_format_parse_context&) = delete; 
    basic_format_parse_context& operator=(const basic_format_parse_context&) = delete; 
 
    constexpr const_iterator begin() const noexcept; 
    constexpr const_iterator end() const noexcept; 
    constexpr void advance_to(const_iterator it); 
 
    constexpr size_t next_arg_id(); 
    constexpr void check_arg_id(size_t id); 
  }; 
  using format_parse_context = basic_format_parse_context<char>; 
  using wformat_parse_context = basic_format_parse_context<wchar_t>; 
} 
 
*/ 
 
// Make sure all feature-test macros are available. 
#include <version> 
// Enable the contents of the header only when libc++ was built with LIBCXX_ENABLE_INCOMPLETE_FEATURES. 
#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) 
 
#include <__config> 
#include <__debug> 
#include <__format/format_arg.h> 
#include <__format/format_args.h> 
#include <__format/format_context.h> 
#include <__format/format_error.h> 
#include <__format/format_parse_context.h> 
#include <__format/format_string.h> 
#include <__format/parser_std_format_spec.h> 
#include <__format/formatter.h> 
#include <__variant/monostate.h> 
#include <array> 
#include <concepts> 
#include <string> 
#include <string_view> 
#include <type_traits> 
 
#ifndef _LIBCPP_HAS_NO_LOCALIZATION 
#include <locale> 
#endif 
 
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
#pragma GCC system_header 
#endif 
 
_LIBCPP_PUSH_MACROS 
#include <__undef_macros> 
 
_LIBCPP_BEGIN_NAMESPACE_STD 
 
#if _LIBCPP_STD_VER > 17 
 
// TODO FMT Remove this once we require compilers with proper C++20 support. 
// If the compiler has no concepts support, the format header will be disabled. 
// Without concepts support enable_if needs to be used and that too much effort 
// to support compilers with partial C++20 support. 
#if !defined(_LIBCPP_HAS_NO_CONCEPTS) 
 
// TODO FMT Evaluate which templates should be external templates. This 
// improves the efficiency of the header. However since the header is still 
// under heavy development and not all classes are stable it makes no sense 
// to do this optimization now. 
 
using format_args = basic_format_args<format_context>; 
using wformat_args = basic_format_args<wformat_context>; 
 
template <class _OutIt, class _CharT> 
using format_args_t = basic_format_args<basic_format_context<_OutIt, _CharT>>; 
 
template <class _Context, class... _Args> 
struct _LIBCPP_TEMPLATE_VIS __format_arg_store { 
  // TODO FMT Use a built-in array. 
  array<basic_format_arg<_Context>, sizeof...(_Args)> __args; 
}; 
 
template <class _Context = format_context, class... _Args> 
_LIBCPP_HIDE_FROM_ABI __format_arg_store<_Context, _Args...> 
make_format_args(const _Args&... __args) { 
  return {basic_format_arg<_Context>(__args)...}; 
} 
 
template <class... _Args> 
_LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...> 
make_wformat_args(const _Args&... __args) { 
  return _VSTD::make_format_args<wformat_context>(__args...); 
} 
 
namespace __format { 
template <class _Tp, class _CharT> 
struct _LIBCPP_TEMPLATE_VIS __formatter_char { 
  _LIBCPP_HIDE_FROM_ABI 
  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) { 
    // TODO FMT Implement this function. 
    return __parse_ctx.begin(); 
  } 
 
  _LIBCPP_HIDE_FROM_ABI 
  auto format(_Tp __c, auto& __ctx) -> decltype(__ctx.out()) { 
    // TODO FMT Implement the parsed formatting arguments. 
    auto __out_it = __ctx.out(); 
    *__out_it++ = _CharT(__c); 
    return __out_it; 
  } 
}; 
 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS __formatter_c_string { 
  _LIBCPP_HIDE_FROM_ABI 
  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) { 
    // TODO FMT Implement this function. 
    return __parse_ctx.begin(); 
  } 
 
  _LIBCPP_HIDE_FROM_ABI 
  auto format(const _CharT* __str, auto& __ctx) -> decltype(__ctx.out()) { 
    // TODO FMT Implement the parsed formatting arguments. 
    auto __out_it = __ctx.out(); 
    while (*__str) 
      *__out_it++ = *__str++; 
    return __out_it; 
  } 
}; 
 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS __formatter_string { 
  _LIBCPP_HIDE_FROM_ABI 
  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) { 
    // TODO FMT Implement this function. 
    return __parse_ctx.begin(); 
  } 
 
  _LIBCPP_HIDE_FROM_ABI 
  auto format(basic_string_view<_CharT> __str, auto& __ctx) 
      -> decltype(__ctx.out()) { 
    // TODO FMT Implement the parsed formatting arguments. 
    auto __out_it = __ctx.out(); 
    for (const auto __c : __str) 
      *__out_it++ = __c; 
    return __out_it; 
  } 
}; 
 
template <class _Tp, class _CharT> 
requires(is_arithmetic_v<_Tp> && 
         !same_as<_Tp, bool>) struct _LIBCPP_HIDE_FROM_ABI 
    __formatter_arithmetic { 
  _LIBCPP_HIDE_FROM_ABI 
  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) { 
    // TODO FMT Implement 
    return __parse_ctx.begin(); 
  } 
 
  _LIBCPP_HIDE_FROM_ABI 
  auto format(_Tp __value, auto& __ctx) -> decltype(__ctx.out()) { 
    return __handle_format(__value, __ctx); 
  } 
 
private: 
  template <class _Uv> 
  _LIBCPP_HIDDEN static string 
  __convert(_Uv __value) requires(same_as<_CharT, char>) { 
    return _VSTD::to_string(__value); 
  } 
  template <class _Uv> 
  _LIBCPP_HIDDEN static wstring 
  __convert(_Uv __value) requires(same_as<_CharT, wchar_t>) { 
    return _VSTD::to_wstring(__value); 
  } 
 
  template <class _Uv> 
  _LIBCPP_HIDDEN auto __handle_format(_Uv __value, auto& __ctx) 
      -> decltype(__ctx.out()) 
#ifndef _LIBCPP_HAS_NO_INT128 
          requires(!same_as<_Uv, __int128_t> && !same_as<_Uv, __uint128_t>) 
#endif 
  { 
    // TODO FMT Implement using formatting arguments 
    // TODO FMT Improve PoC since using std::to_string is inefficient. 
    // Note the code doesn't use std::string::iterator since the unit tests 
    // test with debug iterators and they fail with strings created from 
    // std::to_string. 
    auto __str = __convert(__value); 
    auto __out_it = __ctx.out(); 
    for (size_t __i = 0, __e = __str.size(); __i != __e; ++__i) 
      *__out_it++ = __str[__i]; 
    return __out_it; 
  } 
#ifndef _LIBCPP_HAS_NO_INT128 
  template <class _Uv> 
  _LIBCPP_HIDDEN auto __handle_format(_Uv __value, auto& __ctx) 
      -> decltype(__ctx.out()) requires(same_as<_Uv, __int128_t> || 
                                        same_as<_Uv, __uint128_t>) { 
    using _To = conditional_t<is_signed_v<_Uv>, long long, unsigned long long>; 
    // TODO FMT Implement full 128-bit support. 
    if (__value < numeric_limits<_To>::min() || 
        __value > numeric_limits<_To>::max()) 
      __throw_format_error("128-bit value is outside of implemented range"); 
 
    return __handle_format(static_cast<_To>(__value), __ctx); 
  } 
#endif 
}; 
} // namespace __format 
 
// These specializations are helper stubs and not proper formatters. 
// TODO FMT Implement the proper formatter specializations. 
 
// [format.formatter.spec]/2.1 The specializations 
 
template <> 
struct _LIBCPP_TEMPLATE_VIS formatter<char, char> 
    : public __format::__formatter_char<char, char> {}; 
 
template <> 
struct _LIBCPP_TEMPLATE_VIS formatter<char, wchar_t> 
    : public __format::__formatter_char<char, wchar_t> {}; 
 
template <> 
struct _LIBCPP_TEMPLATE_VIS formatter<wchar_t, wchar_t> 
    : public __format::__formatter_char<wchar_t, wchar_t> {}; 
 
// [format.formatter.spec]/2.2 For each charT, the string type specializations 
 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<_CharT*, _CharT> 
    : public __format::__formatter_c_string<_CharT> { 
  using _Base = __format::__formatter_c_string<_CharT>; 
 
  _LIBCPP_HIDE_FROM_ABI auto format(_CharT* __str, auto& __ctx) 
      -> decltype(__ctx.out()) { 
    _LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have " 
                          "prevented an invalid pointer"); 
    return _Base::format(__str, __ctx); 
  } 
}; 
 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<const _CharT*, _CharT> 
    : public __format::__formatter_c_string<_CharT> {}; 
 
template <class _CharT, size_t _Size> 
struct _LIBCPP_TEMPLATE_VIS formatter<const _CharT[_Size], _CharT> 
    : public __format::__formatter_string<_CharT> { 
  using _Base = __format::__formatter_string<_CharT>; 
 
  _LIBCPP_HIDE_FROM_ABI auto format(const _CharT __str[_Size], auto& __ctx) 
      -> decltype(__ctx.out()) { 
    return _Base::format(_VSTD::basic_string_view<_CharT>(__str, _Size), __ctx); 
  } 
}; 
 
template <class _CharT, class _Traits, class _Allocator> 
struct _LIBCPP_TEMPLATE_VIS 
    formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT> 
    : public __format::__formatter_string<_CharT> { 
  using _Base = __format::__formatter_string<_CharT>; 
 
  _LIBCPP_HIDE_FROM_ABI auto 
  format(const basic_string<_CharT, _Traits, _Allocator>& __str, auto& __ctx) 
      -> decltype(__ctx.out()) { 
    return _Base::format(_VSTD::basic_string_view<_CharT>(__str), __ctx); 
  } 
}; 
 
template <class _CharT, class _Traits> 
struct _LIBCPP_TEMPLATE_VIS 
    formatter<basic_string_view<_CharT, _Traits>, _CharT> 
    : public __format::__formatter_string<_CharT> {}; 
 
// [format.formatter.spec]/2.3 
// For each charT, for each cv-unqualified arithmetic type ArithmeticT other 
// than char, wchar_t, char8_t, char16_t, or char32_t, a specialization 
 
// Boolean. 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<bool, _CharT> { 
  _LIBCPP_HIDE_FROM_ABI 
  auto parse(auto& __parse_ctx) -> decltype(__parse_ctx.begin()) { 
    // TODO FMT Implement 
    return __parse_ctx.begin(); 
  } 
 
  _LIBCPP_HIDE_FROM_ABI 
  auto format(bool __b, auto& __ctx) -> decltype(__ctx.out()) { 
    // TODO FMT Implement using formatting arguments 
    auto __out_it = __ctx.out(); 
    *__out_it++ = _CharT('0') + __b; 
    return __out_it; 
  } 
}; 
 
// Signed integral types. 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<signed char, _CharT> 
    : public __format::__formatter_arithmetic<signed char, _CharT> {}; 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<short, _CharT> 
    : public __format::__formatter_arithmetic<short, _CharT> {}; 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<int, _CharT> 
    : public __format::__formatter_arithmetic<int, _CharT> {}; 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<long, _CharT> 
    : public __format::__formatter_arithmetic<long, _CharT> {}; 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<long long, _CharT> 
    : public __format::__formatter_arithmetic<long long, _CharT> {}; 
#ifndef _LIBCPP_HAS_NO_INT128 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<__int128_t, _CharT> 
    : public __format::__formatter_arithmetic<__int128_t, _CharT> {}; 
#endif 
 
// Unsigned integral types. 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned char, _CharT> 
    : public __format::__formatter_arithmetic<unsigned char, _CharT> {}; 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned short, _CharT> 
    : public __format::__formatter_arithmetic<unsigned short, _CharT> {}; 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned, _CharT> 
    : public __format::__formatter_arithmetic<unsigned, _CharT> {}; 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long, _CharT> 
    : public __format::__formatter_arithmetic<unsigned long, _CharT> {}; 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long long, _CharT> 
    : public __format::__formatter_arithmetic<unsigned long long, _CharT> {}; 
#ifndef _LIBCPP_HAS_NO_INT128 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS formatter<__uint128_t, _CharT> 
    : public __format::__formatter_arithmetic<__uint128_t, _CharT> {}; 
#endif 
 
// Floating point types. 
// TODO FMT There are no replacements for the floating point stubs due to not 
// having floating point support in std::to_chars yet. These stubs aren't 
// removed since they are useful for developing the real versions. 
// Ultimately the stubs should be implemented properly and this code can be 
// removed. 
#if 0 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<float, _CharT> 
    : public __format::__formatter_arithmetic<float, _CharT> {}; 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT 
    formatter<double, _CharT> 
    : public __format::__formatter_arithmetic<double, _CharT> {}; 
template <class _CharT> 
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT 
    formatter<long double, _CharT> 
    : public __format::__formatter_arithmetic<long double, _CharT> {}; 
#endif 
 
namespace __format { 
 
template <class _CharT, class _ParseCtx, class _Ctx> 
_LIBCPP_HIDE_FROM_ABI const _CharT* 
__handle_replacement_field(const _CharT* __begin, const _CharT* __end, 
                           _ParseCtx& __parse_ctx, _Ctx& __ctx) { 
  __format::__parse_number_result __r = 
      __format::__parse_arg_id(__begin, __end, __parse_ctx); 
 
  switch (*__r.__ptr) { 
  case _CharT(':'): 
    // The arg-id has a format-specifier, advance the input to the format-spec. 
    __parse_ctx.advance_to(__r.__ptr + 1); 
    break; 
  case _CharT('}'): 
    // The arg-id has no format-specifier. 
    __parse_ctx.advance_to(__r.__ptr); 
    break; 
  default: 
    __throw_format_error( 
        "The replacement field arg-id should terminate at a ':' or '}'"); 
  } 
 
  _VSTD::visit_format_arg( 
      [&](auto __arg) { 
        if constexpr (same_as<decltype(__arg), monostate>) 
          __throw_format_error("Argument index out of bounds"); 
        else { 
          formatter<decltype(__arg), _CharT> __formatter; 
          __parse_ctx.advance_to(__formatter.parse(__parse_ctx)); 
          __ctx.advance_to(__formatter.format(__arg, __ctx)); 
        } 
      }, 
      __ctx.arg(__r.__value)); 
 
  __begin = __parse_ctx.begin(); 
  if (__begin == __end || *__begin != _CharT('}')) 
    __throw_format_error("The replacement field misses a terminating '}'"); 
 
  return ++__begin; 
} 
 
template <class _ParseCtx, class _Ctx> 
_LIBCPP_HIDE_FROM_ABI typename _Ctx::iterator 
__vformat_to(_ParseCtx&& __parse_ctx, _Ctx&& __ctx) { 
  using _CharT = typename _ParseCtx::char_type; 
  static_assert(same_as<typename _Ctx::char_type, _CharT>); 
 
  const _CharT* __begin = __parse_ctx.begin(); 
  const _CharT* __end = __parse_ctx.end(); 
  typename _Ctx::iterator __out_it = __ctx.out(); 
  while (__begin != __end) { 
    switch (*__begin) { 
    case _CharT('{'): 
      ++__begin; 
      if (__begin == __end) 
        __throw_format_error("The format string terminates at a '{'"); 
 
      if (*__begin != _CharT('{')) [[likely]] { 
        __ctx.advance_to(_VSTD::move(__out_it)); 
        __begin = 
            __handle_replacement_field(__begin, __end, __parse_ctx, __ctx); 
        __out_it = __ctx.out(); 
 
        // The output is written and __begin points to the next character. So 
        // start the next iteration. 
        continue; 
      } 
      // The string is an escape character. 
      break; 
 
    case _CharT('}'): 
      ++__begin; 
      if (__begin == __end || *__begin != _CharT('}')) 
        __throw_format_error( 
            "The format string contains an invalid escape sequence"); 
 
      break; 
    } 
 
    // Copy the character to the output verbatim. 
    *__out_it++ = *__begin++; 
  } 
  return __out_it; 
} 
 
} // namespace __format 
 
template <class _OutIt, class _CharT> 
requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt 
    __vformat_to(_OutIt __out_it, basic_string_view<_CharT> __fmt, 
                 format_args_t<type_identity_t<_OutIt>, _CharT> __args) { 
  return __format::__vformat_to( 
      basic_format_parse_context{__fmt, __args.__size()}, 
      _VSTD::__format_context_create(_VSTD::move(__out_it), __args)); 
} 
 
template <output_iterator<const char&> _OutIt> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt 
vformat_to(_OutIt __out_it, string_view __fmt, 
           format_args_t<type_identity_t<_OutIt>, char> __args) { 
  return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args); 
} 
 
template <output_iterator<const wchar_t&> _OutIt> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt 
vformat_to(_OutIt __out_it, wstring_view __fmt, 
           format_args_t<type_identity_t<_OutIt>, wchar_t> __args) { 
  return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args); 
} 
 
template <output_iterator<const char&> _OutIt, class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt 
format_to(_OutIt __out_it, string_view __fmt, const _Args&... __args) { 
  return _VSTD::vformat_to( 
      _VSTD::move(__out_it), __fmt, 
      _VSTD::make_format_args<basic_format_context<_OutIt, char>>(__args...)); 
} 
 
template <output_iterator<const wchar_t&> _OutIt, class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt 
format_to(_OutIt __out_it, wstring_view __fmt, const _Args&... __args) { 
  return _VSTD::vformat_to( 
      _VSTD::move(__out_it), __fmt, 
      _VSTD::make_format_args<basic_format_context<_OutIt, wchar_t>>( 
          __args...)); 
} 
 
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string 
vformat(string_view __fmt, format_args __args) { 
  string __res; 
  _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args); 
  return __res; 
} 
 
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring 
vformat(wstring_view __fmt, wformat_args __args) { 
  wstring __res; 
  _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args); 
  return __res; 
} 
 
template <class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string 
format(string_view __fmt, const _Args&... __args) { 
  return _VSTD::vformat(__fmt, _VSTD::make_format_args(__args...)); 
} 
 
template <class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring 
format(wstring_view __fmt, const _Args&... __args) { 
  return _VSTD::vformat(__fmt, _VSTD::make_wformat_args(__args...)); 
} 
 
template <class _OutIt> 
struct _LIBCPP_TEMPLATE_VIS format_to_n_result { 
  _OutIt out; 
  iter_difference_t<_OutIt> size; 
}; 
 
template <output_iterator<const char&> _OutIt, class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt> 
format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, string_view __fmt, 
            const _Args&... __args) { 
  // TODO FMT Improve PoC: using std::string is inefficient. 
  string __str = _VSTD::vformat(__fmt, _VSTD::make_format_args(__args...)); 
  iter_difference_t<_OutIt> __s = __str.size(); 
  iter_difference_t<_OutIt> __m = 
      _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s); 
  __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it)); 
  return {_VSTD::move(__out_it), __s}; 
} 
 
template <output_iterator<const wchar_t&> _OutIt, class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt> 
format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, wstring_view __fmt, 
            const _Args&... __args) { 
  // TODO FMT Improve PoC: using std::string is inefficient. 
  wstring __str = _VSTD::vformat(__fmt, _VSTD::make_wformat_args(__args...)); 
  iter_difference_t<_OutIt> __s = __str.size(); 
  iter_difference_t<_OutIt> __m = 
      _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s); 
  __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it)); 
  return {_VSTD::move(__out_it), __s}; 
} 
 
template <class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t 
formatted_size(string_view __fmt, const _Args&... __args) { 
  // TODO FMT Improve PoC: using std::string is inefficient. 
  return _VSTD::vformat(__fmt, _VSTD::make_format_args(__args...)).size(); 
} 
 
template <class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t 
formatted_size(wstring_view __fmt, const _Args&... __args) { 
  // TODO FMT Improve PoC: using std::string is inefficient. 
  return _VSTD::vformat(__fmt, _VSTD::make_wformat_args(__args...)).size(); 
} 
 
#ifndef _LIBCPP_HAS_NO_LOCALIZATION 
 
template <class _OutIt, class _CharT> 
requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt 
    __vformat_to(_OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt, 
                 format_args_t<type_identity_t<_OutIt>, _CharT> __args) { 
  return __format::__vformat_to( 
      basic_format_parse_context{__fmt, __args.__size()}, 
      _VSTD::__format_context_create(_VSTD::move(__out_it), __args, 
                                     _VSTD::move(__loc))); 
} 
 
template <output_iterator<const char&> _OutIt> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt 
vformat_to(_OutIt __out_it, locale __loc, string_view __fmt, 
           format_args_t<type_identity_t<_OutIt>, char> __args) { 
  return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt, 
                             __args); 
} 
 
template <output_iterator<const wchar_t&> _OutIt> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt 
vformat_to(_OutIt __out_it, locale __loc, wstring_view __fmt, 
           format_args_t<type_identity_t<_OutIt>, wchar_t> __args) { 
  return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt, 
                             __args); 
} 
 
template <output_iterator<const char&> _OutIt, class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt format_to( 
    _OutIt __out_it, locale __loc, string_view __fmt, const _Args&... __args) { 
  return _VSTD::vformat_to( 
      _VSTD::move(__out_it), _VSTD::move(__loc), __fmt, 
      _VSTD::make_format_args<basic_format_context<_OutIt, char>>(__args...)); 
} 
 
template <output_iterator<const wchar_t&> _OutIt, class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt format_to( 
    _OutIt __out_it, locale __loc, wstring_view __fmt, const _Args&... __args) { 
  return _VSTD::vformat_to( 
      _VSTD::move(__out_it), _VSTD::move(__loc), __fmt, 
      _VSTD::make_format_args<basic_format_context<_OutIt, wchar_t>>( 
          __args...)); 
} 
 
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string 
vformat(locale __loc, string_view __fmt, format_args __args) { 
  string __res; 
  _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt, 
                    __args); 
  return __res; 
} 
 
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring 
vformat(locale __loc, wstring_view __fmt, wformat_args __args) { 
  wstring __res; 
  _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt, 
                    __args); 
  return __res; 
} 
 
template <class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string 
format(locale __loc, string_view __fmt, const _Args&... __args) { 
  return _VSTD::vformat(_VSTD::move(__loc), __fmt, 
                        _VSTD::make_format_args(__args...)); 
} 
 
template <class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring 
format(locale __loc, wstring_view __fmt, const _Args&... __args) { 
  return _VSTD::vformat(_VSTD::move(__loc), __fmt, 
                        _VSTD::make_wformat_args(__args...)); 
} 
 
template <output_iterator<const char&> _OutIt, class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt> 
format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, 
            string_view __fmt, const _Args&... __args) { 
  // TODO FMT Improve PoC: using std::string is inefficient. 
  string __str = _VSTD::vformat(_VSTD::move(__loc), __fmt, 
                                _VSTD::make_format_args(__args...)); 
  iter_difference_t<_OutIt> __s = __str.size(); 
  iter_difference_t<_OutIt> __m = 
      _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s); 
  __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it)); 
  return {_VSTD::move(__out_it), __s}; 
} 
 
template <output_iterator<const wchar_t&> _OutIt, class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt> 
format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, 
            wstring_view __fmt, const _Args&... __args) { 
  // TODO FMT Improve PoC: using std::string is inefficient. 
  wstring __str = _VSTD::vformat(_VSTD::move(__loc), __fmt, 
                                 _VSTD::make_wformat_args(__args...)); 
  iter_difference_t<_OutIt> __s = __str.size(); 
  iter_difference_t<_OutIt> __m = 
      _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s); 
  __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it)); 
  return {_VSTD::move(__out_it), __s}; 
} 
 
template <class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t 
formatted_size(locale __loc, string_view __fmt, const _Args&... __args) { 
  // TODO FMT Improve PoC: using std::string is inefficient. 
  return _VSTD::vformat(_VSTD::move(__loc), __fmt, 
                        _VSTD::make_format_args(__args...)) 
      .size(); 
} 
 
template <class... _Args> 
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t 
formatted_size(locale __loc, wstring_view __fmt, const _Args&... __args) { 
  // TODO FMT Improve PoC: using std::string is inefficient. 
  return _VSTD::vformat(_VSTD::move(__loc), __fmt, 
                        _VSTD::make_wformat_args(__args...)) 
      .size(); 
} 
 
#endif // _LIBCPP_HAS_NO_LOCALIZATION 
 
#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS) 
#endif //_LIBCPP_STD_VER > 17 
 
_LIBCPP_END_NAMESPACE_STD 
 
_LIBCPP_POP_MACROS 
 
#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) 
 
#endif // _LIBCPP_FORMAT 
 
 
====================File: include/list==================== 
// -*- C++ -*- 
//===---------------------------- list ------------------------------------===// 
// 
// 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_LIST 
#define _LIBCPP_LIST 
 
/* 
    list synopsis 
 
namespace std 
{ 
 
template <class T, class Alloc = allocator<T> > 
class list 
{ 
public: 
 
    // types: 
    typedef T value_type; 
    typedef Alloc allocator_type; 
    typedef typename allocator_type::reference reference; 
    typedef typename allocator_type::const_reference const_reference; 
    typedef typename allocator_type::pointer pointer; 
    typedef typename allocator_type::const_pointer const_pointer; 
    typedef implementation-defined iterator; 
    typedef implementation-defined const_iterator; 
    typedef implementation-defined size_type; 
    typedef implementation-defined difference_type; 
    typedef reverse_iterator<iterator> reverse_iterator; 
    typedef reverse_iterator<const_iterator> const_reverse_iterator; 
 
    list() 
        noexcept(is_nothrow_default_constructible<allocator_type>::value); 
    explicit list(const allocator_type& a); 
    explicit list(size_type n); 
    explicit list(size_type n, const allocator_type& a); // C++14 
    list(size_type n, const value_type& value); 
    list(size_type n, const value_type& value, const allocator_type& a); 
    template <class Iter> 
        list(Iter first, Iter last); 
    template <class Iter> 
        list(Iter first, Iter last, const allocator_type& a); 
    list(const list& x); 
    list(const list&, const allocator_type& a); 
    list(list&& x) 
        noexcept(is_nothrow_move_constructible<allocator_type>::value); 
    list(list&&, const allocator_type& a); 
    list(initializer_list<value_type>); 
    list(initializer_list<value_type>, const allocator_type& a); 
 
    ~list(); 
 
    list& operator=(const list& x); 
    list& operator=(list&& x) 
        noexcept( 
             allocator_type::propagate_on_container_move_assignment::value && 
             is_nothrow_move_assignable<allocator_type>::value); 
    list& operator=(initializer_list<value_type>); 
    template <class Iter> 
        void assign(Iter first, Iter last); 
    void assign(size_type n, const value_type& t); 
    void assign(initializer_list<value_type>); 
 
    allocator_type get_allocator() const noexcept; 
 
    iterator begin() noexcept; 
    const_iterator begin() const noexcept; 
    iterator end() noexcept; 
    const_iterator end() const noexcept; 
    reverse_iterator rbegin() noexcept; 
    const_reverse_iterator rbegin() const noexcept; 
    reverse_iterator rend() noexcept; 
    const_reverse_iterator rend() const noexcept; 
    const_iterator cbegin() const noexcept; 
    const_iterator cend() const noexcept; 
    const_reverse_iterator crbegin() const noexcept; 
    const_reverse_iterator crend() const noexcept; 
 
    reference front(); 
    const_reference front() const; 
    reference back(); 
    const_reference back() const; 
 
    bool empty() const noexcept; 
    size_type size() const noexcept; 
    size_type max_size() const noexcept; 
 
    template <class... Args> 
        reference emplace_front(Args&&... args); // reference in C++17 
    void pop_front(); 
    template <class... Args> 
        reference emplace_back(Args&&... args);  // reference in C++17 
    void pop_back(); 
    void push_front(const value_type& x); 
    void push_front(value_type&& x); 
    void push_back(const value_type& x); 
    void push_back(value_type&& x); 
    template <class... Args> 
        iterator emplace(const_iterator position, Args&&... args); 
    iterator insert(const_iterator position, const value_type& x); 
    iterator insert(const_iterator position, value_type&& x); 
    iterator insert(const_iterator position, size_type n, const value_type& x); 
    template <class Iter> 
        iterator insert(const_iterator position, Iter first, Iter last); 
    iterator insert(const_iterator position, initializer_list<value_type> il); 
 
    iterator erase(const_iterator position); 
    iterator erase(const_iterator position, const_iterator last); 
 
    void resize(size_type sz); 
    void resize(size_type sz, const value_type& c); 
 
    void swap(list&) 
        noexcept(allocator_traits<allocator_type>::is_always_equal::value);  // C++17 
    void clear() noexcept; 
 
    void splice(const_iterator position, list& x); 
    void splice(const_iterator position, list&& x); 
    void splice(const_iterator position, list& x, const_iterator i); 
    void splice(const_iterator position, list&& x, const_iterator i); 
    void splice(const_iterator position, list& x, const_iterator first, 
                                                  const_iterator last); 
    void splice(const_iterator position, list&& x, const_iterator first, 
                                                  const_iterator last); 
 
    size_type remove(const value_type& value);       // void before C++20 
    template <class Pred> 
      size_type remove_if(Pred pred);                // void before C++20 
    size_type unique();                              // void before C++20 
    template <class BinaryPredicate> 
      size_type unique(BinaryPredicate binary_pred); // void before C++20 
    void merge(list& x); 
    void merge(list&& x); 
    template <class Compare> 
        void merge(list& x, Compare comp); 
    template <class Compare> 
        void merge(list&& x, Compare comp); 
    void sort(); 
    template <class Compare> 
        void sort(Compare comp); 
    void reverse() noexcept; 
}; 
 
 
template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> 
    list(InputIterator, InputIterator, Allocator = Allocator()) 
    -> list<typename iterator_traits<InputIterator>::value_type, Allocator>;  // C++17 
 
template <class T, class Alloc> 
    bool operator==(const list<T,Alloc>& x, const list<T,Alloc>& y); 
template <class T, class Alloc> 
    bool operator< (const list<T,Alloc>& x, const list<T,Alloc>& y); 
template <class T, class Alloc> 
    bool operator!=(const list<T,Alloc>& x, const list<T,Alloc>& y); 
template <class T, class Alloc> 
    bool operator> (const list<T,Alloc>& x, const list<T,Alloc>& y); 
template <class T, class Alloc> 
    bool operator>=(const list<T,Alloc>& x, const list<T,Alloc>& y); 
template <class T, class Alloc> 
    bool operator<=(const list<T,Alloc>& x, const list<T,Alloc>& y); 
 
template <class T, class Alloc> 
    void swap(list<T,Alloc>& x, list<T,Alloc>& y) 
         noexcept(noexcept(x.swap(y))); 
 
template <class T, class Allocator, class U> 
    typename list<T, Allocator>::size_type 
    erase(list<T, Allocator>& c, const U& value);       // C++20 
template <class T, class Allocator, class Predicate> 
    typename list<T, Allocator>::size_type 
    erase_if(list<T, Allocator>& c, Predicate pred);    // C++20 
 
}  // std 
 
*/ 
 
#include <__config> 
#include <__debug> 
#include <__utility/forward.h> 
#include <algorithm> 
#include <initializer_list> 
#include <iterator> 
#include <limits> 
#include <memory> 
#include <type_traits> 
#include <version> 
 
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
#pragma GCC system_header 
#endif 
 
_LIBCPP_PUSH_MACROS 
#include <__undef_macros> 
 
 
_LIBCPP_BEGIN_NAMESPACE_STD 
 
template <class _Tp, class _VoidPtr> struct __list_node; 
template <class _Tp, class _VoidPtr> struct __list_node_base; 
 
template <class _Tp, class _VoidPtr> 
struct __list_node_pointer_traits { 
  typedef typename __rebind_pointer<_VoidPtr, __list_node<_Tp, _VoidPtr> >::type 
        __node_pointer; 
  typedef typename __rebind_pointer<_VoidPtr, __list_node_base<_Tp, _VoidPtr> >::type 
        __base_pointer; 
 
#if defined(_LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB) 
  typedef __base_pointer __link_pointer; 
#else 
  typedef typename conditional< 
          is_pointer<_VoidPtr>::value, 
          __base_pointer, 
          __node_pointer 
  >::type __link_pointer; 
#endif 
 
  typedef typename conditional< 
          is_same<__link_pointer, __node_pointer>::value, 
          __base_pointer, 
          __node_pointer 
  >::type __non_link_pointer; 
 
  static _LIBCPP_INLINE_VISIBILITY 
  __link_pointer __unsafe_link_pointer_cast(__link_pointer __p) { 
      return __p; 
  } 
 
  static _LIBCPP_INLINE_VISIBILITY 
  __link_pointer __unsafe_link_pointer_cast(__non_link_pointer __p) { 
      return static_cast<__link_pointer>(static_cast<_VoidPtr>(__p)); 
  } 
 
}; 
 
template <class _Tp, class _VoidPtr> 
struct __list_node_base 
{ 
    typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits; 
    typedef typename _NodeTraits::__node_pointer __node_pointer; 
    typedef typename _NodeTraits::__base_pointer __base_pointer; 
    typedef typename _NodeTraits::__link_pointer __link_pointer; 
 
    __link_pointer __prev_; 
    __link_pointer __next_; 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_node_base() : __prev_(_NodeTraits::__unsafe_link_pointer_cast(__self())), 
                         __next_(_NodeTraits::__unsafe_link_pointer_cast(__self())) {} 
 
    _LIBCPP_INLINE_VISIBILITY 
    __base_pointer __self() { 
        return pointer_traits<__base_pointer>::pointer_to(*this); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    __node_pointer __as_node() { 
        return static_cast<__node_pointer>(__self()); 
    } 
}; 
 
template <class _Tp, class _VoidPtr> 
struct _LIBCPP_STANDALONE_DEBUG __list_node 
    : public __list_node_base<_Tp, _VoidPtr> 
{ 
    _Tp __value_; 
 
    typedef __list_node_base<_Tp, _VoidPtr> __base; 
    typedef typename __base::__link_pointer __link_pointer; 
 
    _LIBCPP_INLINE_VISIBILITY 
    __link_pointer __as_link() { 
        return static_cast<__link_pointer>(__base::__self()); 
    } 
}; 
 
template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS list; 
template <class _Tp, class _Alloc> class __list_imp; 
template <class _Tp, class _VoidPtr> class _LIBCPP_TEMPLATE_VIS __list_const_iterator; 
 
template <class _Tp, class _VoidPtr> 
class _LIBCPP_TEMPLATE_VIS __list_iterator 
{ 
    typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits; 
    typedef typename _NodeTraits::__link_pointer __link_pointer; 
 
    __link_pointer __ptr_; 
 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_INLINE_VISIBILITY 
    explicit __list_iterator(__link_pointer __p, const void* __c) _NOEXCEPT 
        : __ptr_(__p) 
    { 
        __get_db()->__insert_ic(this, __c); 
    } 
#else 
    _LIBCPP_INLINE_VISIBILITY 
    explicit __list_iterator(__link_pointer __p) _NOEXCEPT : __ptr_(__p) {} 
#endif 
 
 
 
    template<class, class> friend class list; 
    template<class, class> friend class __list_imp; 
    template<class, class> friend class __list_const_iterator; 
public: 
    typedef bidirectional_iterator_tag       iterator_category; 
    typedef _Tp                              value_type; 
    typedef value_type&                      reference; 
    typedef typename __rebind_pointer<_VoidPtr, value_type>::type pointer; 
    typedef typename pointer_traits<pointer>::difference_type difference_type; 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_iterator() _NOEXCEPT : __ptr_(nullptr) 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        __get_db()->__insert_i(this); 
#endif 
    } 
 
#if _LIBCPP_DEBUG_LEVEL == 2 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_iterator(const __list_iterator& __p) 
        : __ptr_(__p.__ptr_) 
    { 
        __get_db()->__iterator_copy(this, &__p); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    ~__list_iterator() 
    { 
        __get_db()->__erase_i(this); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_iterator& operator=(const __list_iterator& __p) 
    { 
        if (this != &__p) 
        { 
            __get_db()->__iterator_copy(this, &__p); 
            __ptr_ = __p.__ptr_; 
        } 
        return *this; 
    } 
 
#endif // _LIBCPP_DEBUG_LEVEL == 2 
 
    _LIBCPP_INLINE_VISIBILITY 
    reference operator*() const 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this), 
                       "Attempted to dereference a non-dereferenceable list::iterator"); 
#endif 
        return __ptr_->__as_node()->__value_; 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    pointer operator->() const 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this), 
                       "Attempted to dereference a non-dereferenceable list::iterator"); 
#endif 
        return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__value_); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_iterator& operator++() 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this), 
                       "Attempted to increment a non-incrementable list::iterator"); 
#endif 
        __ptr_ = __ptr_->__next_; 
        return *this; 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    __list_iterator operator++(int) {__list_iterator __t(*this); ++(*this); return __t;} 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_iterator& operator--() 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        _LIBCPP_ASSERT(__get_const_db()->__decrementable(this), 
                       "Attempted to decrement a non-decrementable list::iterator"); 
#endif 
        __ptr_ = __ptr_->__prev_; 
        return *this; 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    __list_iterator operator--(int) {__list_iterator __t(*this); --(*this); return __t;} 
 
    friend _LIBCPP_INLINE_VISIBILITY 
    bool operator==(const __list_iterator& __x, const __list_iterator& __y) 
    { 
        return __x.__ptr_ == __y.__ptr_; 
    } 
    friend _LIBCPP_INLINE_VISIBILITY 
     bool operator!=(const __list_iterator& __x, const __list_iterator& __y) 
        {return !(__x == __y);} 
}; 
 
template <class _Tp, class _VoidPtr> 
class _LIBCPP_TEMPLATE_VIS __list_const_iterator 
{ 
    typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits; 
    typedef typename _NodeTraits::__link_pointer __link_pointer; 
 
    __link_pointer __ptr_; 
 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_INLINE_VISIBILITY 
    explicit __list_const_iterator(__link_pointer __p, const void* __c) _NOEXCEPT 
        : __ptr_(__p) 
    { 
        __get_db()->__insert_ic(this, __c); 
    } 
#else 
    _LIBCPP_INLINE_VISIBILITY 
    explicit __list_const_iterator(__link_pointer __p) _NOEXCEPT : __ptr_(__p) {} 
#endif 
 
    template<class, class> friend class list; 
    template<class, class> friend class __list_imp; 
public: 
    typedef bidirectional_iterator_tag       iterator_category; 
    typedef _Tp                              value_type; 
    typedef const value_type&                reference; 
    typedef typename __rebind_pointer<_VoidPtr, const value_type>::type pointer; 
    typedef typename pointer_traits<pointer>::difference_type difference_type; 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_const_iterator() _NOEXCEPT : __ptr_(nullptr) 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        __get_db()->__insert_i(this); 
#endif 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    __list_const_iterator(const __list_iterator<_Tp, _VoidPtr>& __p) _NOEXCEPT 
        : __ptr_(__p.__ptr_) 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        __get_db()->__iterator_copy(this, &__p); 
#endif 
    } 
 
#if _LIBCPP_DEBUG_LEVEL == 2 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_const_iterator(const __list_const_iterator& __p) 
        : __ptr_(__p.__ptr_) 
    { 
        __get_db()->__iterator_copy(this, &__p); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    ~__list_const_iterator() 
    { 
        __get_db()->__erase_i(this); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_const_iterator& operator=(const __list_const_iterator& __p) 
    { 
        if (this != &__p) 
        { 
            __get_db()->__iterator_copy(this, &__p); 
            __ptr_ = __p.__ptr_; 
        } 
        return *this; 
    } 
 
#endif // _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_INLINE_VISIBILITY 
    reference operator*() const 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this), 
                       "Attempted to dereference a non-dereferenceable list::const_iterator"); 
#endif 
        return __ptr_->__as_node()->__value_; 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    pointer operator->() const 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this), 
                       "Attempted to dereference a non-dereferenceable list::const_iterator"); 
#endif 
        return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__value_); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_const_iterator& operator++() 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this), 
                       "Attempted to increment a non-incrementable list::const_iterator"); 
#endif 
        __ptr_ = __ptr_->__next_; 
        return *this; 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    __list_const_iterator operator++(int) {__list_const_iterator __t(*this); ++(*this); return __t;} 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_const_iterator& operator--() 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        _LIBCPP_ASSERT(__get_const_db()->__decrementable(this), 
                       "Attempted to decrement a non-decrementable list::const_iterator"); 
#endif 
        __ptr_ = __ptr_->__prev_; 
        return *this; 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    __list_const_iterator operator--(int) {__list_const_iterator __t(*this); --(*this); return __t;} 
 
    friend _LIBCPP_INLINE_VISIBILITY 
    bool operator==(const __list_const_iterator& __x, const __list_const_iterator& __y) 
    { 
        return __x.__ptr_ == __y.__ptr_; 
    } 
    friend _LIBCPP_INLINE_VISIBILITY 
    bool operator!=(const __list_const_iterator& __x, const __list_const_iterator& __y) 
        {return !(__x == __y);} 
}; 
 
template <class _Tp, class _Alloc> 
class __list_imp 
{ 
    __list_imp(const __list_imp&); 
    __list_imp& operator=(const __list_imp&); 
public: 
    typedef _Alloc                                                  allocator_type; 
    typedef allocator_traits<allocator_type>                        __alloc_traits; 
    typedef typename __alloc_traits::size_type                      size_type; 
protected: 
    typedef _Tp                                                     value_type; 
    typedef typename __alloc_traits::void_pointer                   __void_pointer; 
    typedef __list_iterator<value_type, __void_pointer>             iterator; 
    typedef __list_const_iterator<value_type, __void_pointer>       const_iterator; 
    typedef __list_node_base<value_type, __void_pointer>            __node_base; 
    typedef __list_node<value_type, __void_pointer>                 __node; 
    typedef typename __rebind_alloc_helper<__alloc_traits, __node>::type __node_allocator; 
    typedef allocator_traits<__node_allocator>                       __node_alloc_traits; 
    typedef typename __node_alloc_traits::pointer                    __node_pointer; 
    typedef typename __node_alloc_traits::pointer                    __node_const_pointer; 
    typedef __list_node_pointer_traits<value_type, __void_pointer> __node_pointer_traits; 
    typedef typename __node_pointer_traits::__link_pointer __link_pointer; 
    typedef __link_pointer __link_const_pointer; 
    typedef typename __alloc_traits::pointer                         pointer; 
    typedef typename __alloc_traits::const_pointer                   const_pointer; 
    typedef typename __alloc_traits::difference_type                 difference_type; 
 
    typedef typename __rebind_alloc_helper<__alloc_traits, __node_base>::type __node_base_allocator; 
    typedef typename allocator_traits<__node_base_allocator>::pointer __node_base_pointer; 
    static_assert((!is_same<allocator_type, __node_allocator>::value), 
                  "internal allocator type must differ from user-specified " 
                  "type; otherwise overload resolution breaks"); 
 
    __node_base __end_; 
    __compressed_pair<size_type, __node_allocator> __size_alloc_; 
 
    _LIBCPP_INLINE_VISIBILITY 
    __link_pointer __end_as_link() const _NOEXCEPT { 
        return __node_pointer_traits::__unsafe_link_pointer_cast( 
                const_cast<__node_base&>(__end_).__self()); 
    } 
 
    _LIBCPP_INLINE_VISIBILITY 
          size_type& __sz() _NOEXCEPT {return __size_alloc_.first();} 
    _LIBCPP_INLINE_VISIBILITY 
    const size_type& __sz() const _NOEXCEPT 
        {return __size_alloc_.first();} 
    _LIBCPP_INLINE_VISIBILITY 
          __node_allocator& __node_alloc() _NOEXCEPT 
          {return __size_alloc_.second();} 
    _LIBCPP_INLINE_VISIBILITY 
    const __node_allocator& __node_alloc() const _NOEXCEPT 
        {return __size_alloc_.second();} 
 
    _LIBCPP_INLINE_VISIBILITY 
    size_type __node_alloc_max_size() const _NOEXCEPT { 
        return __node_alloc_traits::max_size(__node_alloc()); 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    static void __unlink_nodes(__link_pointer __f, __link_pointer __l) _NOEXCEPT; 
 
    _LIBCPP_INLINE_VISIBILITY 
    __list_imp() 
        _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value); 
    _LIBCPP_INLINE_VISIBILITY 
    __list_imp(const allocator_type& __a); 
    _LIBCPP_INLINE_VISIBILITY 
    __list_imp(const __node_allocator& __a); 
#ifndef _LIBCPP_CXX03_LANG 
    __list_imp(__node_allocator&& __a) _NOEXCEPT; 
#endif 
    ~__list_imp(); 
    void clear() _NOEXCEPT; 
    _LIBCPP_INLINE_VISIBILITY 
    bool empty() const _NOEXCEPT {return __sz() == 0;} 
 
    _LIBCPP_INLINE_VISIBILITY 
    iterator begin() _NOEXCEPT 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        return iterator(__end_.__next_, this); 
#else 
        return iterator(__end_.__next_); 
#endif 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    const_iterator begin() const  _NOEXCEPT 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        return const_iterator(__end_.__next_, this); 
#else 
        return const_iterator(__end_.__next_); 
#endif 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    iterator end() _NOEXCEPT 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        return iterator(__end_as_link(), this); 
#else 
        return iterator(__end_as_link()); 
#endif 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    const_iterator end() const _NOEXCEPT 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        return const_iterator(__end_as_link(), this); 
#else 
        return const_iterator(__end_as_link()); 
#endif 
    } 
 
    void swap(__list_imp& __c) 
#if _LIBCPP_STD_VER >= 14 
        _NOEXCEPT; 
#else 
        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || 
                    __is_nothrow_swappable<allocator_type>::value); 
#endif 
 
    _LIBCPP_INLINE_VISIBILITY 
    void __copy_assign_alloc(const __list_imp& __c) 
        {__copy_assign_alloc(__c, integral_constant<bool, 
                      __node_alloc_traits::propagate_on_container_copy_assignment::value>());} 
 
    _LIBCPP_INLINE_VISIBILITY 
    void __move_assign_alloc(__list_imp& __c) 
        _NOEXCEPT_( 
            !__node_alloc_traits::propagate_on_container_move_assignment::value || 
            is_nothrow_move_assignable<__node_allocator>::value) 
        {__move_assign_alloc(__c, integral_constant<bool, 
                      __node_alloc_traits::propagate_on_container_move_assignment::value>());} 
 
private: 
    _LIBCPP_INLINE_VISIBILITY 
    void __copy_assign_alloc(const __list_imp& __c, true_type) 
        { 
            if (__node_alloc() != __c.__node_alloc()) 
                clear(); 
            __node_alloc() = __c.__node_alloc(); 
        } 
 
    _LIBCPP_INLINE_VISIBILITY 
    void __copy_assign_alloc(const __list_imp&, false_type) 
        {} 
 
    _LIBCPP_INLINE_VISIBILITY 
    void __move_assign_alloc(__list_imp& __c, true_type) 
        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value) 
        { 
            __node_alloc() = _VSTD::move(__c.__node_alloc()); 
        } 
 
    _LIBCPP_INLINE_VISIBILITY 
    void __move_assign_alloc(__list_imp&, false_type) 
        _NOEXCEPT 
        {} 
 
    _LIBCPP_INLINE_VISIBILITY 
    void __invalidate_all_iterators() { 
#if _LIBCPP_DEBUG_LEVEL == 2 
      __get_db()->__invalidate_all(this); 
#endif 
    } 
}; 
 
// Unlink nodes [__f, __l] 
template <class _Tp, class _Alloc> 
inline 
void 
__list_imp<_Tp, _Alloc>::__unlink_nodes(__link_pointer __f, __link_pointer __l) 
    _NOEXCEPT 
{ 
    __f->__prev_->__next_ = __l->__next_; 
    __l->__next_->__prev_ = __f->__prev_; 
} 
 
template <class _Tp, class _Alloc> 
inline 
__list_imp<_Tp, _Alloc>::__list_imp() 
        _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value) 
    : __size_alloc_(0, __default_init_tag()) 
{ 
} 
 
template <class _Tp, class _Alloc> 
inline 
__list_imp<_Tp, _Alloc>::__list_imp(const allocator_type& __a) 
    : __size_alloc_(0, __node_allocator(__a)) 
{ 
} 
 
template <class _Tp, class _Alloc> 
inline __list_imp<_Tp, _Alloc>::__list_imp(const __node_allocator& __a) 
    : __size_alloc_(0, __a) {} 
 
#ifndef _LIBCPP_CXX03_LANG 
template <class _Tp, class _Alloc> 
inline __list_imp<_Tp, _Alloc>::__list_imp(__node_allocator&& __a) _NOEXCEPT 
    : __size_alloc_(0, _VSTD::move(__a)) {} 
#endif 
 
template <class _Tp, class _Alloc> 
__list_imp<_Tp, _Alloc>::~__list_imp() { 
  clear(); 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__erase_c(this); 
#endif 
} 
 
template <class _Tp, class _Alloc> 
void 
__list_imp<_Tp, _Alloc>::clear() _NOEXCEPT 
{ 
    if (!empty()) 
    { 
        __node_allocator& __na = __node_alloc(); 
        __link_pointer __f = __end_.__next_; 
        __link_pointer __l = __end_as_link(); 
        __unlink_nodes(__f, __l->__prev_); 
        __sz() = 0; 
        while (__f != __l) 
        { 
            __node_pointer __np = __f->__as_node(); 
            __f = __f->__next_; 
            __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_)); 
            __node_alloc_traits::deallocate(__na, __np, 1); 
        } 
        __invalidate_all_iterators(); 
    } 
} 
 
template <class _Tp, class _Alloc> 
void 
__list_imp<_Tp, _Alloc>::swap(__list_imp& __c) 
#if _LIBCPP_STD_VER >= 14 
        _NOEXCEPT 
#else 
        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || 
                    __is_nothrow_swappable<allocator_type>::value) 
#endif 
{ 
    _LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value || 
                   this->__node_alloc() == __c.__node_alloc(), 
                   "list::swap: Either propagate_on_container_swap must be true" 
                   " or the allocators must compare equal"); 
    using _VSTD::swap; 
    _VSTD::__swap_allocator(__node_alloc(), __c.__node_alloc()); 
    swap(__sz(), __c.__sz()); 
    swap(__end_, __c.__end_); 
    if (__sz() == 0) 
        __end_.__next_ = __end_.__prev_ = __end_as_link(); 
    else 
        __end_.__prev_->__next_ = __end_.__next_->__prev_ = __end_as_link(); 
    if (__c.__sz() == 0) 
        __c.__end_.__next_ = __c.__end_.__prev_ = __c.__end_as_link(); 
    else 
        __c.__end_.__prev_->__next_ = __c.__end_.__next_->__prev_ = __c.__end_as_link(); 
 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __libcpp_db* __db = __get_db(); 
    __c_node* __cn1 = __db->__find_c_and_lock(this); 
    __c_node* __cn2 = __db->__find_c(&__c); 
    _VSTD::swap(__cn1->beg_, __cn2->beg_); 
    _VSTD::swap(__cn1->end_, __cn2->end_); 
    _VSTD::swap(__cn1->cap_, __cn2->cap_); 
    for (__i_node** __p = __cn1->end_; __p != __cn1->beg_;) 
    { 
        --__p; 
        const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_); 
        if (__i->__ptr_ == __c.__end_as_link()) 
        { 
            __cn2->__add(*__p); 
            if (--__cn1->end_ != __p) 
                _VSTD::memmove(__p, __p+1, (__cn1->end_ - __p)*sizeof(__i_node*)); 
        } 
        else 
            (*__p)->__c_ = __cn1; 
    } 
    for (__i_node** __p = __cn2->end_; __p != __cn2->beg_;) 
    { 
        --__p; 
        const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_); 
        if (__i->__ptr_ == __end_as_link()) 
        { 
            __cn1->__add(*__p); 
            if (--__cn2->end_ != __p) 
                _VSTD::memmove(__p, __p+1, (__cn2->end_ - __p)*sizeof(__i_node*)); 
        } 
        else 
            (*__p)->__c_ = __cn2; 
    } 
    __db->unlock(); 
#endif 
} 
 
template <class _Tp, class _Alloc /*= allocator<_Tp>*/> 
class _LIBCPP_TEMPLATE_VIS list 
    : private __list_imp<_Tp, _Alloc> 
{ 
    typedef __list_imp<_Tp, _Alloc> base; 
    typedef typename base::__node              __node; 
    typedef typename base::__node_allocator    __node_allocator; 
    typedef typename base::__node_pointer      __node_pointer; 
    typedef typename base::__node_alloc_traits __node_alloc_traits; 
    typedef typename base::__node_base         __node_base; 
    typedef typename base::__node_base_pointer __node_base_pointer; 
    typedef typename base::__link_pointer __link_pointer; 
 
public: 
    typedef _Tp                                      value_type; 
    typedef _Alloc                                   allocator_type; 
    static_assert((is_same<value_type, typename allocator_type::value_type>::value), 
                  "Invalid allocator::value_type"); 
    typedef value_type&                              reference; 
    typedef const value_type&                        const_reference; 
    typedef typename base::pointer                   pointer; 
    typedef typename base::const_pointer             const_pointer; 
    typedef typename base::size_type                 size_type; 
    typedef typename base::difference_type           difference_type; 
    typedef typename base::iterator                  iterator; 
    typedef typename base::const_iterator            const_iterator; 
    typedef _VSTD::reverse_iterator<iterator>         reverse_iterator; 
    typedef _VSTD::reverse_iterator<const_iterator>   const_reverse_iterator; 
#if _LIBCPP_STD_VER > 17 
    typedef size_type                                __remove_return_type; 
#else 
    typedef void                                     __remove_return_type; 
#endif 
 
    _LIBCPP_INLINE_VISIBILITY 
    list() 
        _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value) 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        __get_db()->__insert_c(this); 
#endif 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    explicit list(const allocator_type& __a) : base(__a) 
    { 
#if _LIBCPP_DEBUG_LEVEL == 2 
        __get_db()->__insert_c(this); 
#endif 
    } 
    explicit list(size_type __n); 
#if _LIBCPP_STD_VER > 11 
    explicit list(size_type __n, const allocator_type& __a); 
#endif 
    list(size_type __n, const value_type& __x); 
    list(size_type __n, const value_type& __x, const allocator_type& __a); 
    template <class _InpIter> 
        list(_InpIter __f, _InpIter __l, 
             typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type* = 0); 
    template <class _InpIter> 
        list(_InpIter __f, _InpIter __l, const allocator_type& __a, 
             typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type* = 0); 
 
    list(const list& __c); 
    list(const list& __c, const __identity_t<allocator_type>& __a); 
    _LIBCPP_INLINE_VISIBILITY 
    list& operator=(const list& __c); 
#ifndef _LIBCPP_CXX03_LANG 
    list(initializer_list<value_type> __il); 
    list(initializer_list<value_type> __il, const allocator_type& __a); 
 
    _LIBCPP_INLINE_VISIBILITY 
    list(list&& __c) 
        _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value); 
    _LIBCPP_INLINE_VISIBILITY 
    list(list&& __c, const __identity_t<allocator_type>& __a); 
    _LIBCPP_INLINE_VISIBILITY 
    list& operator=(list&& __c) 
        _NOEXCEPT_( 
            __node_alloc_traits::propagate_on_container_move_assignment::value && 
            is_nothrow_move_assignable<__node_allocator>::value); 
 
    _LIBCPP_INLINE_VISIBILITY 
    list& operator=(initializer_list<value_type> __il) 
        {assign(__il.begin(), __il.end()); return *this;} 
 
    _LIBCPP_INLINE_VISIBILITY 
    void assign(initializer_list<value_type> __il) 
        {assign(__il.begin(), __il.end());} 
#endif // _LIBCPP_CXX03_LANG 
 
    template <class _InpIter> 
        void assign(_InpIter __f, _InpIter __l, 
             typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type* = 0); 
    void assign(size_type __n, const value_type& __x); 
 
    _LIBCPP_INLINE_VISIBILITY 
    allocator_type get_allocator() const _NOEXCEPT; 
 
    _LIBCPP_INLINE_VISIBILITY 
    size_type size() const _NOEXCEPT     {return base::__sz();} 
    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 
    bool empty() const _NOEXCEPT         {return base::empty();} 
    _LIBCPP_INLINE_VISIBILITY 
    size_type max_size() const _NOEXCEPT 
        { 
            return _VSTD::min<size_type>( 
                base::__node_alloc_max_size(), 
                numeric_limits<difference_type >::max()); 
        } 
 
    _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();} 
    _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 
          reverse_iterator rbegin() _NOEXCEPT 
            {return       reverse_iterator(end());} 
    _LIBCPP_INLINE_VISIBILITY 
    const_reverse_iterator rbegin()  const _NOEXCEPT 
        {return const_reverse_iterator(end());} 
    _LIBCPP_INLINE_VISIBILITY 
          reverse_iterator rend() _NOEXCEPT 
            {return       reverse_iterator(begin());} 
    _LIBCPP_INLINE_VISIBILITY 
    const_reverse_iterator rend()    const _NOEXCEPT 
        {return const_reverse_iterator(begin());} 
    _LIBCPP_INLINE_VISIBILITY 
    const_reverse_iterator crbegin() const _NOEXCEPT 
        {return const_reverse_iterator(end());} 
    _LIBCPP_INLINE_VISIBILITY 
    const_reverse_iterator crend()   const _NOEXCEPT 
        {return const_reverse_iterator(begin());} 
 
    _LIBCPP_INLINE_VISIBILITY 
    reference front() 
    { 
        _LIBCPP_ASSERT(!empty(), "list::front called on empty list"); 
        return base::__end_.__next_->__as_node()->__value_; 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    const_reference front() const 
    { 
        _LIBCPP_ASSERT(!empty(), "list::front called on empty list"); 
        return base::__end_.__next_->__as_node()->__value_; 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    reference back() 
    { 
        _LIBCPP_ASSERT(!empty(), "list::back called on empty list"); 
        return base::__end_.__prev_->__as_node()->__value_; 
    } 
    _LIBCPP_INLINE_VISIBILITY 
    const_reference back() const 
    { 
        _LIBCPP_ASSERT(!empty(), "list::back called on empty list"); 
        return base::__end_.__prev_->__as_node()->__value_; 
    } 
 
#ifndef _LIBCPP_CXX03_LANG 
    void push_front(value_type&& __x); 
    void push_back(value_type&& __x); 
 
    template <class... _Args> 
#if _LIBCPP_STD_VER > 14 
       reference emplace_front(_Args&&... __args); 
#else 
       void      emplace_front(_Args&&... __args); 
#endif 
    template <class... _Args> 
#if _LIBCPP_STD_VER > 14 
        reference emplace_back(_Args&&... __args); 
#else 
       void       emplace_back(_Args&&... __args); 
#endif 
    template <class... _Args> 
        iterator emplace(const_iterator __p, _Args&&... __args); 
 
    iterator insert(const_iterator __p, value_type&& __x); 
 
    _LIBCPP_INLINE_VISIBILITY 
    iterator insert(const_iterator __p, initializer_list<value_type> __il) 
        {return insert(__p, __il.begin(), __il.end());} 
#endif // _LIBCPP_CXX03_LANG 
 
    void push_front(const value_type& __x); 
    void push_back(const value_type& __x); 
 
#ifndef _LIBCPP_CXX03_LANG 
    template <class _Arg> 
    _LIBCPP_INLINE_VISIBILITY 
    void __emplace_back(_Arg&& __arg) { emplace_back(_VSTD::forward<_Arg>(__arg)); } 
#else 
    _LIBCPP_INLINE_VISIBILITY 
    void __emplace_back(value_type const& __arg) { push_back(__arg); } 
#endif 
 
    iterator insert(const_iterator __p, const value_type& __x); 
    iterator insert(const_iterator __p, size_type __n, const value_type& __x); 
    template <class _InpIter> 
        iterator insert(const_iterator __p, _InpIter __f, _InpIter __l, 
             typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type* = 0); 
 
    _LIBCPP_INLINE_VISIBILITY 
    void swap(list& __c) 
#if _LIBCPP_STD_VER >= 14 
        _NOEXCEPT 
#else 
        _NOEXCEPT_(!__node_alloc_traits::propagate_on_container_swap::value || 
                   __is_nothrow_swappable<__node_allocator>::value) 
#endif 
        {base::swap(__c);} 
    _LIBCPP_INLINE_VISIBILITY 
    void clear() _NOEXCEPT {base::clear();} 
 
    void pop_front(); 
    void pop_back(); 
 
    iterator erase(const_iterator __p); 
    iterator erase(const_iterator __f, const_iterator __l); 
 
    void resize(size_type __n); 
    void resize(size_type __n, const value_type& __x); 
 
    void splice(const_iterator __p, list& __c); 
#ifndef _LIBCPP_CXX03_LANG 
    _LIBCPP_INLINE_VISIBILITY 
    void splice(const_iterator __p, list&& __c) {splice(__p, __c);} 
    _LIBCPP_INLINE_VISIBILITY 
    void splice(const_iterator __p, list&& __c, const_iterator __i) 
        {splice(__p, __c, __i);} 
    _LIBCPP_INLINE_VISIBILITY 
    void splice(const_iterator __p, list&& __c, const_iterator __f, const_iterator __l) 
        {splice(__p, __c, __f, __l);} 
#endif 
    void splice(const_iterator __p, list& __c, const_iterator __i); 
    void splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l); 
 
    __remove_return_type remove(const value_type& __x); 
    template <class _Pred> __remove_return_type remove_if(_Pred __pred); 
    _LIBCPP_INLINE_VISIBILITY 
    __remove_return_type unique() { return unique(__equal_to<value_type>()); } 
    template <class _BinaryPred> 
        __remove_return_type unique(_BinaryPred __binary_pred); 
    _LIBCPP_INLINE_VISIBILITY 
    void merge(list& __c); 
#ifndef _LIBCPP_CXX03_LANG 
    _LIBCPP_INLINE_VISIBILITY 
    void merge(list&& __c) {merge(__c);} 
 
    template <class _Comp> 
    _LIBCPP_INLINE_VISIBILITY 
        void merge(list&& __c, _Comp __comp) {merge(__c, __comp);} 
#endif 
    template <class _Comp> 
        void merge(list& __c, _Comp __comp); 
 
    _LIBCPP_INLINE_VISIBILITY 
    void sort(); 
    template <class _Comp> 
        _LIBCPP_INLINE_VISIBILITY 
        void sort(_Comp __comp); 
 
    void reverse() _NOEXCEPT; 
 
    bool __invariants() const; 
 
    typedef __allocator_destructor<__node_allocator> __node_destructor; 
    typedef unique_ptr<__node, __node_destructor> __hold_pointer; 
 
    _LIBCPP_INLINE_VISIBILITY 
    __hold_pointer __allocate_node(__node_allocator& __na) { 
      __node_pointer __p = __node_alloc_traits::allocate(__na, 1); 
      __p->__prev_ = nullptr; 
      return __hold_pointer(__p, __node_destructor(__na, 1)); 
    } 
 
#if _LIBCPP_DEBUG_LEVEL == 2 
 
    bool __dereferenceable(const const_iterator* __i) const; 
    bool __decrementable(const const_iterator* __i) const; 
    bool __addable(const const_iterator* __i, ptrdiff_t __n) const; 
    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const; 
 
#endif // _LIBCPP_DEBUG_LEVEL == 2 
 
private: 
    _LIBCPP_INLINE_VISIBILITY 
    static void __link_nodes  (__link_pointer __p, __link_pointer __f, __link_pointer __l); 
    _LIBCPP_INLINE_VISIBILITY 
    void __link_nodes_at_front(__link_pointer __f, __link_pointer __l); 
    _LIBCPP_INLINE_VISIBILITY 
    void __link_nodes_at_back (__link_pointer __f, __link_pointer __l); 
    iterator __iterator(size_type __n); 
    template <class _Comp> 
        static iterator __sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp); 
 
    void __move_assign(list& __c, true_type) 
        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value); 
    void __move_assign(list& __c, false_type); 
}; 
 
#if _LIBCPP_STD_VER >= 17 
template<class _InputIterator, 
         class _Alloc = allocator<__iter_value_type<_InputIterator>>, 
         class = enable_if_t<__is_allocator<_Alloc>::value> 
         > 
list(_InputIterator, _InputIterator) 
  -> list<__iter_value_type<_InputIterator>, _Alloc>; 
 
template<class _InputIterator, 
         class _Alloc, 
         class = enable_if_t<__is_allocator<_Alloc>::value> 
         > 
list(_InputIterator, _InputIterator, _Alloc) 
  -> list<__iter_value_type<_InputIterator>, _Alloc>; 
#endif 
 
// Link in nodes [__f, __l] just prior to __p 
template <class _Tp, class _Alloc> 
inline 
void 
list<_Tp, _Alloc>::__link_nodes(__link_pointer __p, __link_pointer __f, __link_pointer __l) 
{ 
    __p->__prev_->__next_ = __f; 
    __f->__prev_ = __p->__prev_; 
    __p->__prev_ = __l; 
    __l->__next_ = __p; 
} 
 
// Link in nodes [__f, __l] at the front of the list 
template <class _Tp, class _Alloc> 
inline 
void 
list<_Tp, _Alloc>::__link_nodes_at_front(__link_pointer __f, __link_pointer __l) 
{ 
    __f->__prev_ = base::__end_as_link(); 
    __l->__next_ = base::__end_.__next_; 
    __l->__next_->__prev_ = __l; 
    base::__end_.__next_ = __f; 
} 
 
// Link in nodes [__f, __l] at the back of the list 
template <class _Tp, class _Alloc> 
inline 
void 
list<_Tp, _Alloc>::__link_nodes_at_back(__link_pointer __f, __link_pointer __l) 
{ 
    __l->__next_ = base::__end_as_link(); 
    __f->__prev_ = base::__end_.__prev_; 
    __f->__prev_->__next_ = __f; 
    base::__end_.__prev_ = __l; 
} 
 
 
template <class _Tp, class _Alloc> 
inline 
typename list<_Tp, _Alloc>::iterator 
list<_Tp, _Alloc>::__iterator(size_type __n) 
{ 
    return __n <= base::__sz() / 2 ? _VSTD::next(begin(), __n) 
                                   : _VSTD::prev(end(), base::__sz() - __n); 
} 
 
template <class _Tp, class _Alloc> 
list<_Tp, _Alloc>::list(size_type __n) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    for (; __n > 0; --__n) 
#ifndef _LIBCPP_CXX03_LANG 
        emplace_back(); 
#else 
        push_back(value_type()); 
#endif 
} 
 
#if _LIBCPP_STD_VER > 11 
template <class _Tp, class _Alloc> 
list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : base(__a) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    for (; __n > 0; --__n) 
        emplace_back(); 
} 
#endif 
 
template <class _Tp, class _Alloc> 
list<_Tp, _Alloc>::list(size_type __n, const value_type& __x) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    for (; __n > 0; --__n) 
        push_back(__x); 
} 
 
template <class _Tp, class _Alloc> 
list<_Tp, _Alloc>::list(size_type __n, const value_type& __x, const allocator_type& __a) 
    : base(__a) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    for (; __n > 0; --__n) 
        push_back(__x); 
} 
 
template <class _Tp, class _Alloc> 
template <class _InpIter> 
list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l, 
                        typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    for (; __f != __l; ++__f) 
        __emplace_back(*__f); 
} 
 
template <class _Tp, class _Alloc> 
template <class _InpIter> 
list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l, const allocator_type& __a, 
                        typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*) 
    : base(__a) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    for (; __f != __l; ++__f) 
        __emplace_back(*__f); 
} 
 
template <class _Tp, class _Alloc> 
list<_Tp, _Alloc>::list(const list& __c) 
    : base(__node_alloc_traits::select_on_container_copy_construction( 
          __c.__node_alloc())) { 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i) 
        push_back(*__i); 
} 
 
template <class _Tp, class _Alloc> 
list<_Tp, _Alloc>::list(const list& __c, const __identity_t<allocator_type>& __a) 
    : base(__a) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i) 
        push_back(*__i); 
} 
 
#ifndef _LIBCPP_CXX03_LANG 
 
template <class _Tp, class _Alloc> 
list<_Tp, _Alloc>::list(initializer_list<value_type> __il, const allocator_type& __a) 
    : base(__a) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    for (typename initializer_list<value_type>::const_iterator __i = __il.begin(), 
            __e = __il.end(); __i != __e; ++__i) 
        push_back(*__i); 
} 
 
template <class _Tp, class _Alloc> 
list<_Tp, _Alloc>::list(initializer_list<value_type> __il) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    for (typename initializer_list<value_type>::const_iterator __i = __il.begin(), 
            __e = __il.end(); __i != __e; ++__i) 
        push_back(*__i); 
} 
 
template <class _Tp, class _Alloc> 
inline list<_Tp, _Alloc>::list(list&& __c) 
    _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value) 
    : base(_VSTD::move(__c.__node_alloc())) { 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    splice(end(), __c); 
} 
 
template <class _Tp, class _Alloc> 
inline 
list<_Tp, _Alloc>::list(list&& __c, const __identity_t<allocator_type>& __a) 
    : base(__a) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __get_db()->__insert_c(this); 
#endif 
    if (__a == __c.get_allocator()) 
        splice(end(), __c); 
    else 
    { 
        typedef move_iterator<iterator> _Ip; 
        assign(_Ip(__c.begin()), _Ip(__c.end())); 
    } 
} 
 
template <class _Tp, class _Alloc> 
inline 
list<_Tp, _Alloc>& 
list<_Tp, _Alloc>::operator=(list&& __c) 
        _NOEXCEPT_( 
            __node_alloc_traits::propagate_on_container_move_assignment::value && 
            is_nothrow_move_assignable<__node_allocator>::value) 
{ 
    __move_assign(__c, integral_constant<bool, 
          __node_alloc_traits::propagate_on_container_move_assignment::value>()); 
    return *this; 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::__move_assign(list& __c, false_type) 
{ 
    if (base::__node_alloc() != __c.__node_alloc()) 
    { 
        typedef move_iterator<iterator> _Ip; 
        assign(_Ip(__c.begin()), _Ip(__c.end())); 
    } 
    else 
        __move_assign(__c, true_type()); 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::__move_assign(list& __c, true_type) 
        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value) 
{ 
    clear(); 
    base::__move_assign_alloc(__c); 
    splice(end(), __c); 
} 
 
#endif // _LIBCPP_CXX03_LANG 
 
template <class _Tp, class _Alloc> 
inline 
list<_Tp, _Alloc>& 
list<_Tp, _Alloc>::operator=(const list& __c) 
{ 
    if (this != &__c) 
    { 
        base::__copy_assign_alloc(__c); 
        assign(__c.begin(), __c.end()); 
    } 
    return *this; 
} 
 
template <class _Tp, class _Alloc> 
template <class _InpIter> 
void 
list<_Tp, _Alloc>::assign(_InpIter __f, _InpIter __l, 
                          typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*) 
{ 
    iterator __i = begin(); 
    iterator __e = end(); 
    for (; __f != __l && __i != __e; ++__f, (void) ++__i) 
        *__i = *__f; 
    if (__i == __e) 
        insert(__e, __f, __l); 
    else 
        erase(__i, __e); 
#if _LIBCPP_DEBUG_LEVEL == 2 
      __get_db()->__invalidate_all(this); 
#endif 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::assign(size_type __n, const value_type& __x) 
{ 
    iterator __i = begin(); 
    iterator __e = end(); 
    for (; __n > 0 && __i != __e; --__n, (void) ++__i) 
        *__i = __x; 
    if (__i == __e) 
        insert(__e, __n, __x); 
    else 
        erase(__i, __e); 
#if _LIBCPP_DEBUG_LEVEL == 2 
      __get_db()->__invalidate_all(this); 
#endif 
} 
 
template <class _Tp, class _Alloc> 
inline 
_Alloc 
list<_Tp, _Alloc>::get_allocator() const _NOEXCEPT 
{ 
    return allocator_type(base::__node_alloc()); 
} 
 
template <class _Tp, class _Alloc> 
typename list<_Tp, _Alloc>::iterator 
list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
        "list::insert(iterator, x) called with an iterator not" 
        " referring to this list"); 
#endif 
    __node_allocator& __na = base::__node_alloc(); 
    __hold_pointer __hold = __allocate_node(__na); 
    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); 
    __link_nodes(__p.__ptr_, __hold->__as_link(), __hold->__as_link()); 
    ++base::__sz(); 
#if _LIBCPP_DEBUG_LEVEL == 2 
    return iterator(__hold.release()->__as_link(), this); 
#else 
    return iterator(__hold.release()->__as_link()); 
#endif 
} 
 
template <class _Tp, class _Alloc> 
typename list<_Tp, _Alloc>::iterator 
list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& __x) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
        "list::insert(iterator, n, x) called with an iterator not" 
        " referring to this list"); 
    iterator __r(__p.__ptr_, this); 
#else 
    iterator __r(__p.__ptr_); 
#endif 
    if (__n > 0) 
    { 
        size_type __ds = 0; 
        __node_allocator& __na = base::__node_alloc(); 
        __hold_pointer __hold = __allocate_node(__na); 
        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); 
        ++__ds; 
#if _LIBCPP_DEBUG_LEVEL == 2 
        __r = iterator(__hold->__as_link(), this); 
#else 
        __r = iterator(__hold->__as_link()); 
#endif 
        __hold.release(); 
        iterator __e = __r; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try 
        { 
#endif // _LIBCPP_NO_EXCEPTIONS 
            for (--__n; __n != 0; --__n, (void) ++__e, ++__ds) 
            { 
                __hold.reset(__node_alloc_traits::allocate(__na, 1)); 
                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); 
                __e.__ptr_->__next_ = __hold->__as_link(); 
                __hold->__prev_ = __e.__ptr_; 
                __hold.release(); 
            } 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        } 
        catch (...) 
        { 
            while (true) 
            { 
                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); 
                __link_pointer __prev = __e.__ptr_->__prev_; 
                __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); 
                if (__prev == 0) 
                    break; 
#if _LIBCPP_DEBUG_LEVEL == 2 
                __e = iterator(__prev, this); 
#else 
                __e = iterator(__prev); 
#endif 
            } 
            throw; 
        } 
#endif // _LIBCPP_NO_EXCEPTIONS 
        __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_); 
        base::__sz() += __ds; 
    } 
    return __r; 
} 
 
template <class _Tp, class _Alloc> 
template <class _InpIter> 
typename list<_Tp, _Alloc>::iterator 
list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l, 
             typename enable_if<__is_cpp17_input_iterator<_InpIter>::value>::type*) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
        "list::insert(iterator, range) called with an iterator not" 
        " referring to this list"); 
    iterator __r(__p.__ptr_, this); 
#else 
    iterator __r(__p.__ptr_); 
#endif 
    if (__f != __l) 
    { 
        size_type __ds = 0; 
        __node_allocator& __na = base::__node_alloc(); 
        __hold_pointer __hold = __allocate_node(__na); 
        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f); 
        ++__ds; 
#if _LIBCPP_DEBUG_LEVEL == 2 
        __r = iterator(__hold.get()->__as_link(), this); 
#else 
        __r = iterator(__hold.get()->__as_link()); 
#endif 
        __hold.release(); 
        iterator __e = __r; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try 
        { 
#endif // _LIBCPP_NO_EXCEPTIONS 
            for (++__f; __f != __l; ++__f, (void) ++__e, ++__ds) 
            { 
                __hold.reset(__node_alloc_traits::allocate(__na, 1)); 
                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f); 
                __e.__ptr_->__next_ = __hold.get()->__as_link(); 
                __hold->__prev_ = __e.__ptr_; 
                __hold.release(); 
            } 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        } 
        catch (...) 
        { 
            while (true) 
            { 
                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); 
                __link_pointer __prev = __e.__ptr_->__prev_; 
                __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); 
                if (__prev == 0) 
                    break; 
#if _LIBCPP_DEBUG_LEVEL == 2 
                __e = iterator(__prev, this); 
#else 
                __e = iterator(__prev); 
#endif 
            } 
            throw; 
        } 
#endif // _LIBCPP_NO_EXCEPTIONS 
        __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_); 
        base::__sz() += __ds; 
    } 
    return __r; 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::push_front(const value_type& __x) 
{ 
    __node_allocator& __na = base::__node_alloc(); 
    __hold_pointer __hold = __allocate_node(__na); 
    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); 
    __link_pointer __nl = __hold->__as_link(); 
    __link_nodes_at_front(__nl, __nl); 
    ++base::__sz(); 
    __hold.release(); 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::push_back(const value_type& __x) 
{ 
    __node_allocator& __na = base::__node_alloc(); 
    __hold_pointer __hold = __allocate_node(__na); 
    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); 
    __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link()); 
    ++base::__sz(); 
    __hold.release(); 
} 
 
#ifndef _LIBCPP_CXX03_LANG 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::push_front(value_type&& __x) 
{ 
    __node_allocator& __na = base::__node_alloc(); 
    __hold_pointer __hold = __allocate_node(__na); 
    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x)); 
    __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link()); 
    ++base::__sz(); 
    __hold.release(); 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::push_back(value_type&& __x) 
{ 
    __node_allocator& __na = base::__node_alloc(); 
    __hold_pointer __hold = __allocate_node(__na); 
    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x)); 
    __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link()); 
    ++base::__sz(); 
    __hold.release(); 
} 
 
template <class _Tp, class _Alloc> 
template <class... _Args> 
#if _LIBCPP_STD_VER > 14 
typename list<_Tp, _Alloc>::reference 
#else 
void 
#endif 
list<_Tp, _Alloc>::emplace_front(_Args&&... __args) 
{ 
    __node_allocator& __na = base::__node_alloc(); 
    __hold_pointer __hold = __allocate_node(__na); 
    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); 
    __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link()); 
    ++base::__sz(); 
#if _LIBCPP_STD_VER > 14 
    return __hold.release()->__value_; 
#else 
    __hold.release(); 
#endif 
} 
 
template <class _Tp, class _Alloc> 
template <class... _Args> 
#if _LIBCPP_STD_VER > 14 
typename list<_Tp, _Alloc>::reference 
#else 
void 
#endif 
list<_Tp, _Alloc>::emplace_back(_Args&&... __args) 
{ 
    __node_allocator& __na = base::__node_alloc(); 
    __hold_pointer __hold = __allocate_node(__na); 
    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); 
    __link_pointer __nl = __hold->__as_link(); 
    __link_nodes_at_back(__nl, __nl); 
    ++base::__sz(); 
#if _LIBCPP_STD_VER > 14 
    return __hold.release()->__value_; 
#else 
    __hold.release(); 
#endif 
} 
 
template <class _Tp, class _Alloc> 
template <class... _Args> 
typename list<_Tp, _Alloc>::iterator 
list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
        "list::emplace(iterator, args...) called with an iterator not" 
        " referring to this list"); 
#endif 
    __node_allocator& __na = base::__node_alloc(); 
    __hold_pointer __hold = __allocate_node(__na); 
    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); 
    __link_pointer __nl = __hold.get()->__as_link(); 
    __link_nodes(__p.__ptr_, __nl, __nl); 
    ++base::__sz(); 
    __hold.release(); 
#if _LIBCPP_DEBUG_LEVEL == 2 
    return iterator(__nl, this); 
#else 
    return iterator(__nl); 
#endif 
} 
 
template <class _Tp, class _Alloc> 
typename list<_Tp, _Alloc>::iterator 
list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
        "list::insert(iterator, x) called with an iterator not" 
        " referring to this list"); 
#endif 
    __node_allocator& __na = base::__node_alloc(); 
    __hold_pointer __hold = __allocate_node(__na); 
    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x)); 
    __link_pointer __nl = __hold->__as_link(); 
    __link_nodes(__p.__ptr_, __nl, __nl); 
    ++base::__sz(); 
    __hold.release(); 
#if _LIBCPP_DEBUG_LEVEL == 2 
    return iterator(__nl, this); 
#else 
    return iterator(__nl); 
#endif 
} 
 
#endif // _LIBCPP_CXX03_LANG 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::pop_front() 
{ 
    _LIBCPP_ASSERT(!empty(), "list::pop_front() called with empty list"); 
    __node_allocator& __na = base::__node_alloc(); 
    __link_pointer __n = base::__end_.__next_; 
    base::__unlink_nodes(__n, __n); 
    --base::__sz(); 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __c_node* __c = __get_db()->__find_c_and_lock(this); 
    for (__i_node** __p = __c->end_; __p != __c->beg_; ) 
    { 
        --__p; 
        iterator* __i = static_cast<iterator*>((*__p)->__i_); 
        if (__i->__ptr_ == __n) 
        { 
            (*__p)->__c_ = nullptr; 
            if (--__c->end_ != __p) 
                _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*)); 
        } 
    } 
    __get_db()->unlock(); 
#endif 
    __node_pointer __np = __n->__as_node(); 
    __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_)); 
    __node_alloc_traits::deallocate(__na, __np, 1); 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::pop_back() 
{ 
    _LIBCPP_ASSERT(!empty(), "list::pop_back() called on an empty list"); 
    __node_allocator& __na = base::__node_alloc(); 
    __link_pointer __n = base::__end_.__prev_; 
    base::__unlink_nodes(__n, __n); 
    --base::__sz(); 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __c_node* __c = __get_db()->__find_c_and_lock(this); 
    for (__i_node** __p = __c->end_; __p != __c->beg_; ) 
    { 
        --__p; 
        iterator* __i = static_cast<iterator*>((*__p)->__i_); 
        if (__i->__ptr_ == __n) 
        { 
            (*__p)->__c_ = nullptr; 
            if (--__c->end_ != __p) 
                _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*)); 
        } 
    } 
    __get_db()->unlock(); 
#endif 
    __node_pointer __np = __n->__as_node(); 
    __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_)); 
    __node_alloc_traits::deallocate(__na, __np, 1); 
} 
 
template <class _Tp, class _Alloc> 
typename list<_Tp, _Alloc>::iterator 
list<_Tp, _Alloc>::erase(const_iterator __p) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
        "list::erase(iterator) called with an iterator not" 
        " referring to this list"); 
#endif 
    _LIBCPP_ASSERT(__p != end(), 
        "list::erase(iterator) called with a non-dereferenceable iterator"); 
    __node_allocator& __na = base::__node_alloc(); 
    __link_pointer __n = __p.__ptr_; 
    __link_pointer __r = __n->__next_; 
    base::__unlink_nodes(__n, __n); 
    --base::__sz(); 
#if _LIBCPP_DEBUG_LEVEL == 2 
    __c_node* __c = __get_db()->__find_c_and_lock(this); 
    for (__i_node** __ip = __c->end_; __ip != __c->beg_; ) 
    { 
        --__ip; 
        iterator* __i = static_cast<iterator*>((*__ip)->__i_); 
        if (__i->__ptr_ == __n) 
        { 
            (*__ip)->__c_ = nullptr; 
            if (--__c->end_ != __ip) 
                _VSTD::memmove(__ip, __ip+1, (__c->end_ - __ip)*sizeof(__i_node*)); 
        } 
    } 
    __get_db()->unlock(); 
#endif 
    __node_pointer __np = __n->__as_node(); 
    __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_)); 
    __node_alloc_traits::deallocate(__na, __np, 1); 
#if _LIBCPP_DEBUG_LEVEL == 2 
    return iterator(__r, this); 
#else 
    return iterator(__r); 
#endif 
} 
 
template <class _Tp, class _Alloc> 
typename list<_Tp, _Alloc>::iterator 
list<_Tp, _Alloc>::erase(const_iterator __f, const_iterator __l) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__f) == this, 
        "list::erase(iterator, iterator) called with an iterator not" 
        " referring to this list"); 
   _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__l) == this, 
        "list::erase(iterator, iterator) called with an iterator not" 
        " referring to this list"); 
#endif 
    if (__f != __l) 
    { 
        __node_allocator& __na = base::__node_alloc(); 
        base::__unlink_nodes(__f.__ptr_, __l.__ptr_->__prev_); 
        while (__f != __l) 
        { 
            __link_pointer __n = __f.__ptr_; 
            ++__f; 
            --base::__sz(); 
#if _LIBCPP_DEBUG_LEVEL == 2 
            __c_node* __c = __get_db()->__find_c_and_lock(this); 
            for (__i_node** __p = __c->end_; __p != __c->beg_; ) 
            { 
                --__p; 
                iterator* __i = static_cast<iterator*>((*__p)->__i_); 
                if (__i->__ptr_ == __n) 
                { 
                    (*__p)->__c_ = nullptr; 
                    if (--__c->end_ != __p) 
                        _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*)); 
                } 
            } 
            __get_db()->unlock(); 
#endif 
            __node_pointer __np = __n->__as_node(); 
            __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_)); 
            __node_alloc_traits::deallocate(__na, __np, 1); 
        } 
    } 
#if _LIBCPP_DEBUG_LEVEL == 2 
    return iterator(__l.__ptr_, this); 
#else 
    return iterator(__l.__ptr_); 
#endif 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::resize(size_type __n) 
{ 
    if (__n < base::__sz()) 
        erase(__iterator(__n), end()); 
    else if (__n > base::__sz()) 
    { 
        __n -= base::__sz(); 
        size_type __ds = 0; 
        __node_allocator& __na = base::__node_alloc(); 
        __hold_pointer __hold = __allocate_node(__na); 
        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_)); 
        ++__ds; 
#if _LIBCPP_DEBUG_LEVEL == 2 
        iterator __r = iterator(__hold.release()->__as_link(), this); 
#else 
        iterator __r = iterator(__hold.release()->__as_link()); 
#endif 
        iterator __e = __r; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try 
        { 
#endif // _LIBCPP_NO_EXCEPTIONS 
            for (--__n; __n != 0; --__n, (void) ++__e, ++__ds) 
            { 
                __hold.reset(__node_alloc_traits::allocate(__na, 1)); 
                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_)); 
                __e.__ptr_->__next_ = __hold.get()->__as_link(); 
                __hold->__prev_ = __e.__ptr_; 
                __hold.release(); 
            } 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        } 
        catch (...) 
        { 
            while (true) 
            { 
                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); 
                __link_pointer __prev = __e.__ptr_->__prev_; 
                __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); 
                if (__prev == 0) 
                    break; 
#if _LIBCPP_DEBUG_LEVEL == 2 
                __e = iterator(__prev, this); 
#else 
                __e = iterator(__prev); 
#endif 
            } 
            throw; 
        } 
#endif // _LIBCPP_NO_EXCEPTIONS 
        __link_nodes_at_back(__r.__ptr_, __e.__ptr_); 
        base::__sz() += __ds; 
    } 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x) 
{ 
    if (__n < base::__sz()) 
        erase(__iterator(__n), end()); 
    else if (__n > base::__sz()) 
    { 
        __n -= base::__sz(); 
        size_type __ds = 0; 
        __node_allocator& __na = base::__node_alloc(); 
        __hold_pointer __hold = __allocate_node(__na); 
        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); 
        ++__ds; 
        __link_pointer __nl = __hold.release()->__as_link(); 
#if _LIBCPP_DEBUG_LEVEL == 2 
        iterator __r = iterator(__nl, this); 
#else 
        iterator __r = iterator(__nl); 
#endif 
        iterator __e = __r; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try 
        { 
#endif // _LIBCPP_NO_EXCEPTIONS 
            for (--__n; __n != 0; --__n, (void) ++__e, ++__ds) 
            { 
                __hold.reset(__node_alloc_traits::allocate(__na, 1)); 
                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); 
                __e.__ptr_->__next_ = __hold.get()->__as_link(); 
                __hold->__prev_ = __e.__ptr_; 
                __hold.release(); 
            } 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        } 
        catch (...) 
        { 
            while (true) 
            { 
                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); 
                __link_pointer __prev = __e.__ptr_->__prev_; 
                __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); 
                if (__prev == 0) 
                    break; 
#if _LIBCPP_DEBUG_LEVEL == 2 
                __e = iterator(__prev, this); 
#else 
                __e = iterator(__prev); 
#endif 
            } 
            throw; 
        } 
#endif // _LIBCPP_NO_EXCEPTIONS 
        __link_nodes(base::__end_as_link(), __r.__ptr_, __e.__ptr_); 
        base::__sz() += __ds; 
    } 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::splice(const_iterator __p, list& __c) 
{ 
    _LIBCPP_ASSERT(this != &__c, 
                   "list::splice(iterator, list) called with this == &list"); 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
        "list::splice(iterator, list) called with an iterator not" 
        " referring to this list"); 
#endif 
    if (!__c.empty()) 
    { 
        __link_pointer __f = __c.__end_.__next_; 
        __link_pointer __l = __c.__end_.__prev_; 
        base::__unlink_nodes(__f, __l); 
        __link_nodes(__p.__ptr_, __f, __l); 
        base::__sz() += __c.__sz(); 
        __c.__sz() = 0; 
#if _LIBCPP_DEBUG_LEVEL == 2 
        if (&__c != this) { 
            __libcpp_db* __db = __get_db(); 
            __c_node* __cn1 = __db->__find_c_and_lock(this); 
            __c_node* __cn2 = __db->__find_c(&__c); 
            for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;) 
            { 
                --__ip; 
                iterator* __i = static_cast<iterator*>((*__ip)->__i_); 
                if (__i->__ptr_ != __c.__end_as_link()) 
                { 
                    __cn1->__add(*__ip); 
                    (*__ip)->__c_ = __cn1; 
                    if (--__cn2->end_ != __ip) 
                        memmove(__ip, __ip+1, (__cn2->end_ - __ip)*sizeof(__i_node*)); 
                } 
            } 
            __db->unlock(); 
        } 
#endif 
    } 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __i) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
        "list::splice(iterator, list, iterator) called with the first iterator" 
        " not referring to this list"); 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__i) == &__c, 
        "list::splice(iterator, list, iterator) called with the second iterator" 
        " not referring to the list argument"); 
    _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(&__i), 
        "list::splice(iterator, list, iterator) called with the second iterator" 
        " not dereferenceable"); 
#endif 
    if (__p.__ptr_ != __i.__ptr_ && __p.__ptr_ != __i.__ptr_->__next_) 
    { 
        __link_pointer __f = __i.__ptr_; 
        base::__unlink_nodes(__f, __f); 
        __link_nodes(__p.__ptr_, __f, __f); 
        --__c.__sz(); 
        ++base::__sz(); 
#if _LIBCPP_DEBUG_LEVEL == 2 
        if (&__c != this) { 
            __libcpp_db* __db = __get_db(); 
            __c_node* __cn1 = __db->__find_c_and_lock(this); 
            __c_node* __cn2 = __db->__find_c(&__c); 
            for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;) 
            { 
                --__ip; 
                iterator* __j = static_cast<iterator*>((*__ip)->__i_); 
                if (__j->__ptr_ == __f) 
                { 
                    __cn1->__add(*__ip); 
                    (*__ip)->__c_ = __cn1; 
                    if (--__cn2->end_ != __ip) 
                        _VSTD::memmove(__ip, __ip+1, (__cn2->end_ - __ip)*sizeof(__i_node*)); 
                } 
            } 
            __db->unlock(); 
        } 
#endif 
    } 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l) 
{ 
#if _LIBCPP_DEBUG_LEVEL == 2 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, 
        "list::splice(iterator, list, iterator, iterator) called with first iterator not" 
        " referring to this list"); 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__f) == &__c, 
        "list::splice(iterator, list, iterator, iterator) called with second iterator not" 
        " referring to the list argument"); 
    _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__l) == &__c, 
        "list::splice(iterator, list, iterator, iterator) called with third iterator not" 
        " referring to the list argument"); 
    if (this == &__c) 
    { 
        for (const_iterator __i = __f; __i != __l; ++__i) 
            _LIBCPP_ASSERT(__i != __p, 
                           "list::splice(iterator, list, iterator, iterator)" 
                           " called with the first iterator within the range" 
                           " of the second and third iterators"); 
    } 
#endif 
    if (__f != __l) 
    { 
        __link_pointer __first = __f.__ptr_; 
        --__l; 
        __link_pointer __last = __l.__ptr_; 
        if (this != &__c) 
        { 
            size_type __s = _VSTD::distance(__f, __l) + 1; 
            __c.__sz() -= __s; 
            base::__sz() += __s; 
        } 
        base::__unlink_nodes(__first, __last); 
        __link_nodes(__p.__ptr_, __first, __last); 
#if _LIBCPP_DEBUG_LEVEL == 2 
        if (&__c != this) { 
            __libcpp_db* __db = __get_db(); 
            __c_node* __cn1 = __db->__find_c_and_lock(this); 
            __c_node* __cn2 = __db->__find_c(&__c); 
            for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;) 
            { 
                --__ip; 
                iterator* __j = static_cast<iterator*>((*__ip)->__i_); 
                for (__link_pointer __k = __f.__ptr_; 
                                              __k != __l.__ptr_; __k = __k->__next_) 
                { 
                    if (__j->__ptr_ == __k) 
                    { 
                        __cn1->__add(*__ip); 
                        (*__ip)->__c_ = __cn1; 
                        if (--__cn2->end_ != __ip) 
                            _VSTD::memmove(__ip, __ip+1, (__cn2->end_ - __ip)*sizeof(__i_node*)); 
                    } 
                } 
            } 
            __db->unlock(); 
        } 
#endif 
    } 
} 
 
template <class _Tp, class _Alloc> 
typename list<_Tp, _Alloc>::__remove_return_type 
list<_Tp, _Alloc>::remove(const value_type& __x) 
{ 
    list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing 
    for (const_iterator __i = begin(), __e = end(); __i != __e;) 
    { 
        if (*__i == __x) 
        { 
            const_iterator __j = _VSTD::next(__i); 
            for (; __j != __e && *__j == __x; ++__j) 
                ; 
            __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j); 
            __i = __j; 
            if (__i != __e) 
                ++__i; 
        } 
        else 
            ++__i; 
    } 
 
    return (__remove_return_type) __deleted_nodes.size(); 
} 
 
template <class _Tp, class _Alloc> 
template <class _Pred> 
typename list<_Tp, _Alloc>::__remove_return_type 
list<_Tp, _Alloc>::remove_if(_Pred __pred) 
{ 
    list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing 
    for (iterator __i = begin(), __e = end(); __i != __e;) 
    { 
        if (__pred(*__i)) 
        { 
            iterator __j = _VSTD::next(__i); 
            for (; __j != __e && __pred(*__j); ++__j) 
                ; 
            __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j); 
            __i = __j; 
            if (__i != __e) 
                ++__i; 
        } 
        else 
            ++__i; 
    } 
 
    return (__remove_return_type) __deleted_nodes.size(); 
} 
 
template <class _Tp, class _Alloc> 
template <class _BinaryPred> 
typename list<_Tp, _Alloc>::__remove_return_type 
list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred) 
{ 
    list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing 
    for (iterator __i = begin(), __e = end(); __i != __e;) 
    { 
        iterator __j = _VSTD::next(__i); 
        for (; __j != __e && __binary_pred(*__i, *__j); ++__j) 
            ; 
        if (++__i != __j) { 
            __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j); 
            __i = __j; 
            } 
    } 
 
    return (__remove_return_type) __deleted_nodes.size(); 
} 
 
template <class _Tp, class _Alloc> 
inline 
void 
list<_Tp, _Alloc>::merge(list& __c) 
{ 
    merge(__c, __less<value_type>()); 
} 
 
template <class _Tp, class _Alloc> 
template <class _Comp> 
void 
list<_Tp, _Alloc>::merge(list& __c, _Comp __comp) 
{ 
    if (this != _VSTD::addressof(__c)) 
    { 
        iterator __f1 = begin(); 
        iterator __e1 = end(); 
        iterator __f2 = __c.begin(); 
        iterator __e2 = __c.end(); 
        while (__f1 != __e1 && __f2 != __e2) 
        { 
            if (__comp(*__f2, *__f1)) 
            { 
                size_type __ds = 1; 
                iterator __m2 = _VSTD::next(__f2); 
                for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, (void) ++__ds) 
                    ; 
                base::__sz() += __ds; 
                __c.__sz() -= __ds; 
                __link_pointer __f = __f2.__ptr_; 
                __link_pointer __l = __m2.__ptr_->__prev_; 
                __f2 = __m2; 
                base::__unlink_nodes(__f, __l); 
                __m2 = _VSTD::next(__f1); 
                __link_nodes(__f1.__ptr_, __f, __l); 
                __f1 = __m2; 
            } 
            else 
                ++__f1; 
        } 
        splice(__e1, __c); 
#if _LIBCPP_DEBUG_LEVEL == 2 
        __libcpp_db* __db = __get_db(); 
        __c_node* __cn1 = __db->__find_c_and_lock(this); 
        __c_node* __cn2 = __db->__find_c(&__c); 
        for (__i_node** __p = __cn2->end_; __p != __cn2->beg_;) 
        { 
            --__p; 
            iterator* __i = static_cast<iterator*>((*__p)->__i_); 
            if (__i->__ptr_ != __c.__end_as_link()) 
            { 
                __cn1->__add(*__p); 
                (*__p)->__c_ = __cn1; 
                if (--__cn2->end_ != __p) 
                    _VSTD::memmove(__p, __p+1, (__cn2->end_ - __p)*sizeof(__i_node*)); 
            } 
        } 
        __db->unlock(); 
#endif 
    } 
} 
 
template <class _Tp, class _Alloc> 
inline 
void 
list<_Tp, _Alloc>::sort() 
{ 
    sort(__less<value_type>()); 
} 
 
template <class _Tp, class _Alloc> 
template <class _Comp> 
inline 
void 
list<_Tp, _Alloc>::sort(_Comp __comp) 
{ 
    __sort(begin(), end(), base::__sz(), __comp); 
} 
 
template <class _Tp, class _Alloc> 
template <class _Comp> 
typename list<_Tp, _Alloc>::iterator 
list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp) 
{ 
    switch (__n) 
    { 
    case 0: 
    case 1: 
        return __f1; 
    case 2: 
        if (__comp(*--__e2, *__f1)) 
        { 
            __link_pointer __f = __e2.__ptr_; 
            base::__unlink_nodes(__f, __f); 
            __link_nodes(__f1.__ptr_, __f, __f); 
            return __e2; 
        } 
        return __f1; 
    } 
    size_type __n2 = __n / 2; 
    iterator __e1 = _VSTD::next(__f1, __n2); 
    iterator  __r = __f1 = __sort(__f1, __e1, __n2, __comp); 
    iterator __f2 = __e1 = __sort(__e1, __e2, __n - __n2, __comp); 
    if (__comp(*__f2, *__f1)) 
    { 
        iterator __m2 = _VSTD::next(__f2); 
        for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2) 
            ; 
        __link_pointer __f = __f2.__ptr_; 
        __link_pointer __l = __m2.__ptr_->__prev_; 
        __r = __f2; 
        __e1 = __f2 = __m2; 
        base::__unlink_nodes(__f, __l); 
        __m2 = _VSTD::next(__f1); 
        __link_nodes(__f1.__ptr_, __f, __l); 
        __f1 = __m2; 
    } 
    else 
        ++__f1; 
    while (__f1 != __e1 && __f2 != __e2) 
    { 
        if (__comp(*__f2, *__f1)) 
        { 
            iterator __m2 = _VSTD::next(__f2); 
            for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2) 
                ; 
            __link_pointer __f = __f2.__ptr_; 
            __link_pointer __l = __m2.__ptr_->__prev_; 
            if (__e1 == __f2) 
                __e1 = __m2; 
            __f2 = __m2; 
            base::__unlink_nodes(__f, __l); 
            __m2 = _VSTD::next(__f1); 
            __link_nodes(__f1.__ptr_, __f, __l); 
            __f1 = __m2; 
        } 
        else 
            ++__f1; 
    } 
    return __r; 
} 
 
template <class _Tp, class _Alloc> 
void 
list<_Tp, _Alloc>::reverse() _NOEXCEPT 
{ 
    if (base::__sz() > 1) 
    { 
        iterator __e = end(); 
        for (iterator __i = begin(); __i.__ptr_ != __e.__ptr_;) 
        { 
            _VSTD::swap(__i.__ptr_->__prev_, __i.__ptr_->__next_); 
            __i.__ptr_ = __i.__ptr_->__prev_; 
        } 
        _VSTD::swap(__e.__ptr_->__prev_, __e.__ptr_->__next_); 
    } 
} 
 
template <class _Tp, class _Alloc> 
bool 
list<_Tp, _Alloc>::__invariants() const 
{ 
    return size() == _VSTD::distance(begin(), end()); 
} 
 
#if _LIBCPP_DEBUG_LEVEL == 2 
 
template <class _Tp, class _Alloc> 
bool 
list<_Tp, _Alloc>::__dereferenceable(const const_iterator* __i) const 
{ 
    return __i->__ptr_ != this->__end_as_link(); 
} 
 
template <class _Tp, class _Alloc> 
bool 
list<_Tp, _Alloc>::__decrementable(const const_iterator* __i) const 
{ 
    return !empty() &&  __i->__ptr_ != base::__end_.__next_; 
} 
 
template <class _Tp, class _Alloc> 
bool 
list<_Tp, _Alloc>::__addable(const const_iterator*, ptrdiff_t) const 
{ 
    return false; 
} 
 
template <class _Tp, class _Alloc> 
bool 
list<_Tp, _Alloc>::__subscriptable(const const_iterator*, ptrdiff_t) const 
{ 
    return false; 
} 
 
#endif // _LIBCPP_DEBUG_LEVEL == 2 
 
template <class _Tp, class _Alloc> 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) 
{ 
    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin()); 
} 
 
template <class _Tp, class _Alloc> 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator< (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) 
{ 
    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); 
} 
 
template <class _Tp, class _Alloc> 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) 
{ 
    return !(__x == __y); 
} 
 
template <class _Tp, class _Alloc> 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator> (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) 
{ 
    return __y < __x; 
} 
 
template <class _Tp, class _Alloc> 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) 
{ 
    return !(__x < __y); 
} 
 
template <class _Tp, class _Alloc> 
inline _LIBCPP_INLINE_VISIBILITY 
bool 
operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) 
{ 
    return !(__y < __x); 
} 
 
template <class _Tp, class _Alloc> 
inline _LIBCPP_INLINE_VISIBILITY 
void 
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) 
    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) 
{ 
    __x.swap(__y); 
} 
 
#if _LIBCPP_STD_VER > 17 
template <class _Tp, class _Allocator, class _Predicate> 
inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type 
erase_if(list<_Tp, _Allocator>& __c, _Predicate __pred) { 
  return __c.remove_if(__pred); 
} 
 
template <class _Tp, class _Allocator, class _Up> 
inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type 
erase(list<_Tp, _Allocator>& __c, const _Up& __v) { 
  return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); 
} 
#endif 
 
_LIBCPP_END_NAMESPACE_STD 
 
_LIBCPP_POP_MACROS 
 
#endif // _LIBCPP_LIST 
 
 
====================File: include/version==================== 
// -*- C++ -*- 
//===--------------------------- version ----------------------------------===// 
// 
// 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_VERSIONH 
#define _LIBCPP_VERSIONH 
 
/* 
  version synopsis 
 
Macro name                                              Value   Headers 
__cpp_lib_addressof_constexpr                           201603L <memory> 
__cpp_lib_allocator_traits_is_always_equal              201411L <deque> <forward_list> <list> 
                                                                <map> <memory> <scoped_allocator> 
                                                                <set> <string> <unordered_map> 
                                                                <unordered_set> <vector> 
__cpp_lib_any                                           201606L <any> 
__cpp_lib_apply                                         201603L <tuple> 
__cpp_lib_array_constexpr                               201811L <array> <iterator> 
                                                        201603L // C++17 
__cpp_lib_as_const                                      201510L <utility> 
__cpp_lib_assume_aligned                                201811L <memory> 
__cpp_lib_atomic_flag_test                              201907L <atomic> 
__cpp_lib_atomic_float                                  201711L <atomic> 
__cpp_lib_atomic_is_always_lock_free                    201603L <atomic> 
__cpp_lib_atomic_lock_free_type_aliases                 201907L <atomic> 
__cpp_lib_atomic_ref                                    201806L <atomic> 
__cpp_lib_atomic_shared_ptr                             201711L <atomic> 
__cpp_lib_atomic_value_initialization                   201911L <atomic> <memory> 
__cpp_lib_atomic_wait                                   201907L <atomic> 
__cpp_lib_barrier                                       201907L <barrier> 
__cpp_lib_bind_front                                    201907L <functional> 
__cpp_lib_bit_cast                                      201806L <bit> 
__cpp_lib_bitops                                        201907L <bit> 
__cpp_lib_bool_constant                                 201505L <type_traits> 
__cpp_lib_bounded_array_traits                          201902L <type_traits> 
__cpp_lib_boyer_moore_searcher                          201603L <functional> 
__cpp_lib_byte                                          201603L <cstddef> 
__cpp_lib_char8_t                                       201907L <atomic> <filesystem> <istream> 
                                                                <limits> <locale> <ostream> 
                                                                <string> <string_view> 
__cpp_lib_chrono                                        201611L <chrono> 
__cpp_lib_chrono_udls                                   201304L <chrono> 
__cpp_lib_clamp                                         201603L <algorithm> 
__cpp_lib_complex_udls                                  201309L <complex> 
__cpp_lib_concepts                                      202002L <concepts> 
__cpp_lib_constexpr_algorithms                          201806L <algorithm> 
__cpp_lib_constexpr_complex                             201711L <complex> 
__cpp_lib_constexpr_dynamic_alloc                       201907L <memory> 
__cpp_lib_constexpr_functional                          201907L <functional> 
__cpp_lib_constexpr_iterator                            201811L <iterator> 
__cpp_lib_constexpr_memory                              201811L <memory> 
__cpp_lib_constexpr_numeric                             201911L <numeric> 
__cpp_lib_constexpr_string                              201811L <string> 
__cpp_lib_constexpr_string_view                         201811L <string_view> 
__cpp_lib_constexpr_tuple                               201811L <tuple> 
__cpp_lib_constexpr_utility                             201811L <utility> 
__cpp_lib_constexpr_vector                              201907L <vector> 
__cpp_lib_coroutine                                     201902L <coroutine> 
__cpp_lib_destroying_delete                             201806L <new> 
__cpp_lib_enable_shared_from_this                       201603L <memory> 
__cpp_lib_endian                                        201907L <bit> 
__cpp_lib_erase_if                                      202002L <deque> <forward_list> <list> 
                                                                <map> <set> <string> 
                                                                <unordered_map> <unordered_set> <vector> 
__cpp_lib_exchange_function                             201304L <utility> 
__cpp_lib_execution                                     201902L <execution> 
                                                        201603L // C++17 
__cpp_lib_filesystem                                    201703L <filesystem> 
__cpp_lib_format                                        201907L <format> 
__cpp_lib_gcd_lcm                                       201606L <numeric> 
__cpp_lib_generic_associative_lookup                    201304L <map> <set> 
__cpp_lib_generic_unordered_lookup                      201811L <unordered_map> <unordered_set> 
__cpp_lib_hardware_interference_size                    201703L <new> 
__cpp_lib_has_unique_object_representations             201606L <type_traits> 
__cpp_lib_hypot                                         201603L <cmath> 
__cpp_lib_incomplete_container_elements                 201505L <forward_list> <list> <vector> 
__cpp_lib_int_pow2                                      202002L <bit> 
__cpp_lib_integer_comparison_functions                  202002L <utility> 
__cpp_lib_integer_sequence                              201304L <utility> 
__cpp_lib_integral_constant_callable                    201304L <type_traits> 
__cpp_lib_interpolate                                   201902L <cmath> <numeric> 
__cpp_lib_invoke                                        201411L <functional> 
__cpp_lib_is_aggregate                                  201703L <type_traits> 
__cpp_lib_is_constant_evaluated                         201811L <type_traits> 
__cpp_lib_is_final                                      201402L <type_traits> 
__cpp_lib_is_invocable                                  201703L <type_traits> 
__cpp_lib_is_layout_compatible                          201907L <type_traits> 
__cpp_lib_is_nothrow_convertible                        201806L <type_traits> 
__cpp_lib_is_null_pointer                               201309L <type_traits> 
__cpp_lib_is_pointer_interconvertible                   201907L <type_traits> 
__cpp_lib_is_scoped_enum                                202011L <type_traits> 
__cpp_lib_is_swappable                                  201603L <type_traits> 
__cpp_lib_jthread                                       201911L <stop_token> <thread> 
__cpp_lib_latch                                         201907L <latch> 
__cpp_lib_launder                                       201606L <new> 
__cpp_lib_list_remove_return_type                       201806L <forward_list> <list> 
__cpp_lib_logical_traits                                201510L <type_traits> 
__cpp_lib_make_from_tuple                               201606L <tuple> 
__cpp_lib_make_reverse_iterator                         201402L <iterator> 
__cpp_lib_make_unique                                   201304L <memory> 
__cpp_lib_map_try_emplace                               201411L <map> 
__cpp_lib_math_constants                                201907L <numbers> 
__cpp_lib_math_special_functions                        201603L <cmath> 
__cpp_lib_memory_resource                               201603L <memory_resource> 
__cpp_lib_node_extract                                  201606L <map> <set> <unordered_map> 
                                                                <unordered_set> 
__cpp_lib_nonmember_container_access                    201411L <array> <deque> <forward_list> 
                                                                <iterator> <list> <map> 
                                                                <regex> <set> <string> 
                                                                <unordered_map> <unordered_set> <vector> 
__cpp_lib_not_fn                                        201603L <functional> 
__cpp_lib_null_iterators                                201304L <iterator> 
__cpp_lib_optional                                      201606L <optional> 
__cpp_lib_parallel_algorithm                            201603L <algorithm> <numeric> 
__cpp_lib_polymorphic_allocator                         201902L <memory> 
__cpp_lib_quoted_string_io                              201304L <iomanip> 
__cpp_lib_ranges                                        201811L <algorithm> <functional> <iterator> 
                                                                <memory> <ranges> 
__cpp_lib_raw_memory_algorithms                         201606L <memory> 
__cpp_lib_remove_cvref                                  201711L <type_traits> 
__cpp_lib_result_of_sfinae                              201210L <functional> <type_traits> 
__cpp_lib_robust_nonmodifying_seq_ops                   201304L <algorithm> 
__cpp_lib_sample                                        201603L <algorithm> 
__cpp_lib_scoped_lock                                   201703L <mutex> 
__cpp_lib_semaphore                                     201907L <semaphore> 
__cpp_lib_shared_mutex                                  201505L <shared_mutex> 
__cpp_lib_shared_ptr_arrays                             201611L <memory> 
__cpp_lib_shared_ptr_weak_type                          201606L <memory> 
__cpp_lib_shared_timed_mutex                            201402L <shared_mutex> 
__cpp_lib_shift                                         201806L <algorithm> 
__cpp_lib_smart_ptr_for_overwrite                       202002L <memory> 
__cpp_lib_source_location                               201907L <source_location> 
__cpp_lib_span                                          202002L <span> 
__cpp_lib_ssize                                         201902L <iterator> 
__cpp_lib_stacktrace                                    202011L <stacktrace> 
__cpp_lib_starts_ends_with                              201711L <string> <string_view> 
__cpp_lib_stdatomic_h                                   202011L <stdatomic.h> 
__cpp_lib_string_contains                               202011L <string> <string_view> 
__cpp_lib_string_udls                                   201304L <string> 
__cpp_lib_string_view                                   201803L <string> <string_view> 
                                                        201606L // C++17 
__cpp_lib_syncbuf                                       201803L <syncstream> 
__cpp_lib_three_way_comparison                          201907L <compare> 
__cpp_lib_to_address                                    201711L <memory> 
__cpp_lib_to_array                                      201907L <array> 
__cpp_lib_to_chars                                      201611L <utility> 
__cpp_lib_to_underlying                                 202102L <utility> 
__cpp_lib_transformation_trait_aliases                  201304L <type_traits> 
__cpp_lib_transparent_operators                         201510L <functional> <memory> 
                                                        201210L // C++14 
__cpp_lib_tuple_element_t                               201402L <tuple> 
__cpp_lib_tuples_by_type                                201304L <tuple> <utility> 
__cpp_lib_type_trait_variable_templates                 201510L <type_traits> 
__cpp_lib_uncaught_exceptions                           201411L <exception> 
__cpp_lib_unordered_map_try_emplace                     201411L <unordered_map> 
__cpp_lib_unwrap_ref                                    201811L <functional> 
__cpp_lib_variant                                       202102L <variant> 
__cpp_lib_void_t                                        201411L <type_traits> 
 
*/ 
 
#include <__config> 
 
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
#pragma GCC system_header 
#endif 
 
// clang-format off 
 
#if _LIBCPP_STD_VER > 11 
# define __cpp_lib_chrono_udls                          201304L 
# define __cpp_lib_complex_udls                         201309L 
# define __cpp_lib_exchange_function                    201304L 
# define __cpp_lib_generic_associative_lookup           201304L 
# define __cpp_lib_integer_sequence                     201304L 
# define __cpp_lib_integral_constant_callable           201304L 
# define __cpp_lib_is_final                             201402L 
# define __cpp_lib_is_null_pointer                      201309L 
# define __cpp_lib_make_reverse_iterator                201402L 
# define __cpp_lib_make_unique                          201304L 
# define __cpp_lib_null_iterators                       201304L 
# define __cpp_lib_quoted_string_io                     201304L 
# define __cpp_lib_result_of_sfinae                     201210L 
# define __cpp_lib_robust_nonmodifying_seq_ops          201304L 
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex) 
#   define __cpp_lib_shared_timed_mutex                 201402L 
# endif 
# define __cpp_lib_string_udls                          201304L 
# define __cpp_lib_transformation_trait_aliases         201304L 
# define __cpp_lib_transparent_operators                201210L 
# define __cpp_lib_tuple_element_t                      201402L 
# define __cpp_lib_tuples_by_type                       201304L 
#endif 
 
#if _LIBCPP_STD_VER > 14 
# define __cpp_lib_addressof_constexpr                  201603L 
# define __cpp_lib_allocator_traits_is_always_equal     201411L 
# define __cpp_lib_any                                  201606L 
# define __cpp_lib_apply                                201603L 
# if defined(_MSC_VER) && _MSC_VER >= 1926 
#   define __cpp_lib_array_constexpr                    201803L 
# else 
#   define __cpp_lib_array_constexpr                    201603L 
# endif 
# define __cpp_lib_as_const                             201510L 
# if !defined(_LIBCPP_HAS_NO_THREADS) 
#   define __cpp_lib_atomic_is_always_lock_free         201603L 
# endif 
# define __cpp_lib_bool_constant                        201505L 
// # define __cpp_lib_boyer_moore_searcher                 201603L 
# define __cpp_lib_byte                                 201603L 
# define __cpp_lib_chrono                               201611L 
# define __cpp_lib_clamp                                201603L 
# define __cpp_lib_enable_shared_from_this              201603L 
// # define __cpp_lib_execution                            201603L 
# if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem) 
# define __cpp_lib_filesystem                           201703L 
# endif 
# define __cpp_lib_gcd_lcm                              201606L 
// # define __cpp_lib_hardware_interference_size           201703L 
# define __cpp_lib_has_unique_object_representations    201606L 
# define __cpp_lib_hypot                                201603L 
# define __cpp_lib_incomplete_container_elements        201505L 
# define __cpp_lib_invoke                               201411L 
# define __cpp_lib_is_aggregate                         201703L 
# define __cpp_lib_is_invocable                         201703L 
# define __cpp_lib_is_swappable                         201603L 
# define __cpp_lib_launder                              201606L 
# define __cpp_lib_logical_traits                       201510L 
# define __cpp_lib_make_from_tuple                      201606L 
# define __cpp_lib_map_try_emplace                      201411L 
// # define __cpp_lib_math_special_functions               201603L 
// # define __cpp_lib_memory_resource                      201603L 
# define __cpp_lib_node_extract                         201606L 
# define __cpp_lib_nonmember_container_access           201411L 
# define __cpp_lib_not_fn                               201603L 
# define __cpp_lib_optional                             201606L 
// # define __cpp_lib_parallel_algorithm                   201603L 
# define __cpp_lib_raw_memory_algorithms                201606L 
# define __cpp_lib_sample                               201603L 
# define __cpp_lib_scoped_lock                          201703L 
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex) 
#   define __cpp_lib_shared_mutex                       201505L 
# endif 
# define __cpp_lib_shared_ptr_arrays                    201611L 
# define __cpp_lib_shared_ptr_weak_type                 201606L 
# if defined(_MSC_VER) && _MSC_VER >= 1926 
#   define __cpp_lib_string_view                        201803L 
# else 
#   define __cpp_lib_string_view                        201606L 
# endif 
// # define __cpp_lib_to_chars                             201611L 
# undef  __cpp_lib_transparent_operators 
# define __cpp_lib_transparent_operators                201510L 
# define __cpp_lib_type_trait_variable_templates        201510L 
# define __cpp_lib_uncaught_exceptions                  201411L 
# define __cpp_lib_unordered_map_try_emplace            201411L 
# define __cpp_lib_variant                              202102L 
# define __cpp_lib_void_t                               201411L 
#endif 
 
#if _LIBCPP_STD_VER > 17 
# undef  __cpp_lib_array_constexpr 
# define __cpp_lib_array_constexpr                      201811L 
// # define __cpp_lib_assume_aligned                       201811L 
# if !defined(_LIBCPP_HAS_NO_THREADS) 
#   define __cpp_lib_atomic_flag_test                   201907L 
# endif 
# if !defined(_LIBCPP_HAS_NO_THREADS) 
// #   define __cpp_lib_atomic_float                       201711L 
# endif 
# if !defined(_LIBCPP_HAS_NO_THREADS) 
#   define __cpp_lib_atomic_lock_free_type_aliases      201907L 
# endif 
# if !defined(_LIBCPP_HAS_NO_THREADS) 
// #   define __cpp_lib_atomic_ref                         201806L 
# endif 
# if !defined(_LIBCPP_HAS_NO_THREADS) 
// #   define __cpp_lib_atomic_shared_ptr                  201711L 
# endif 
# if !defined(_LIBCPP_HAS_NO_THREADS) 
#   define __cpp_lib_atomic_value_initialization        201911L 
# endif 
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait) 
#   define __cpp_lib_atomic_wait                        201907L 
# endif 
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier) 
#   define __cpp_lib_barrier                            201907L 
# endif 
# define __cpp_lib_bind_front                           201907L 
# define __cpp_lib_bit_cast                             201806L 
// # define __cpp_lib_bitops                               201907L 
# define __cpp_lib_bounded_array_traits                 201902L 
# if !defined(_LIBCPP_HAS_NO_CHAR8_T) 
#   define __cpp_lib_char8_t                            201907L 
# endif 
# define __cpp_lib_concepts                             202002L 
# define __cpp_lib_constexpr_algorithms                 201806L 
// # define __cpp_lib_constexpr_complex                    201711L 
# define __cpp_lib_constexpr_dynamic_alloc              201907L 
# define __cpp_lib_constexpr_functional                 201907L 
# define __cpp_lib_constexpr_iterator                   201811L 
# define __cpp_lib_constexpr_memory                     201811L 
# define __cpp_lib_constexpr_numeric                    201911L 
# define __cpp_lib_constexpr_string                     201811L 
# define __cpp_lib_constexpr_string_view                201811L 
# define __cpp_lib_constexpr_tuple                      201811L 
# define __cpp_lib_constexpr_utility                    201811L 
// # define __cpp_lib_constexpr_vector                     201907L 
// # define __cpp_lib_coroutine                            201902L 
# if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L 
#   define __cpp_lib_destroying_delete                  201806L 
# endif 
# define __cpp_lib_endian                               201907L 
# define __cpp_lib_erase_if                             202002L 
# undef  __cpp_lib_execution 
// # define __cpp_lib_execution                            201902L 
# if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format) 
// #   define __cpp_lib_format                             201907L 
# endif 
# define __cpp_lib_generic_unordered_lookup             201811L 
# define __cpp_lib_int_pow2                             202002L 
# if !defined(_LIBCPP_HAS_NO_CONCEPTS) 
#   define __cpp_lib_integer_comparison_functions       202002L 
# endif 
# define __cpp_lib_interpolate                          201902L 
# define __cpp_lib_is_constant_evaluated                201811L 
// # define __cpp_lib_is_layout_compatible                 201907L 
# define __cpp_lib_is_nothrow_convertible               201806L 
// # define __cpp_lib_is_pointer_interconvertible          201907L 
# if !defined(_LIBCPP_HAS_NO_THREADS) 
// #   define __cpp_lib_jthread                            201911L 
# endif 
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch) 
#   define __cpp_lib_latch                              201907L 
# endif 
# define __cpp_lib_list_remove_return_type              201806L 
# if !defined(_LIBCPP_HAS_NO_CONCEPTS) 
#   define __cpp_lib_math_constants                     201907L 
# endif 
// # define __cpp_lib_polymorphic_allocator                201902L 
// # define __cpp_lib_ranges                               201811L 
# define __cpp_lib_remove_cvref                         201711L 
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore) 
#   define __cpp_lib_semaphore                          201907L 
# endif 
# define __cpp_lib_shift                                201806L 
// # define __cpp_lib_smart_ptr_for_overwrite              202002L 
// # define __cpp_lib_source_location                      201907L 
# define __cpp_lib_span                                 202002L 
# define __cpp_lib_ssize                                201902L 
# define __cpp_lib_starts_ends_with                     201711L 
# undef  __cpp_lib_string_view 
# define __cpp_lib_string_view                          201803L 
// # define __cpp_lib_syncbuf                              201803L 
// # define __cpp_lib_three_way_comparison                 201907L 
# define __cpp_lib_to_address                           201711L 
# define __cpp_lib_to_array                             201907L 
# define __cpp_lib_unwrap_ref                           201811L 
#endif 
 
#if _LIBCPP_STD_VER > 20 
# define __cpp_lib_is_scoped_enum                       202011L 
// # define __cpp_lib_stacktrace                           202011L 
// # define __cpp_lib_stdatomic_h                          202011L 
# define __cpp_lib_string_contains                      202011L 
# define __cpp_lib_to_underlying                        202102L 
#endif 
 
// clang-format on 
 
#endif // _LIBCPP_VERSIONH 
 
 
====================MIT====================
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

====================NCSA====================
Legacy LLVM License (https://llvm.org/docs/DeveloperPolicy.html#legacy):


====================NCSA====================
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal with
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimers.

    * Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimers in the
      documentation and/or other materials provided with the distribution.

    * Neither the names of the LLVM Team, University of Illinois at
      Urbana-Champaign, nor the names of its contributors may be used to
      endorse or promote products derived from this Software without specific
      prior written permission.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
SOFTWARE.


====================NCSA====================
University of Illinois/NCSA
Open Source License


====================NCSA AND MIT====================
The libc++ library is dual licensed under both the University of Illinois
"BSD-Like" license and the MIT license.  As a user of this code you may choose
to use it under either license.  As a contributor, you agree to allow your code
to be used under both.

Full text of the relevant licenses is included below.