<h2>File Contents: //usr/include/c++/8/tuple</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='//usr/include/c++/8/tuple'><textarea name='file_content' rows='10' cols='50'>// &lt;tuple&gt; -*- C++ -*-

// Copyright (C) 2007-2018 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file include/tuple
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_TUPLE
#define _GLIBCXX_TUPLE 1

#pragma GCC system_header

#if __cplusplus &lt; 201103L
# include &lt;bits/c++0x_warning.h&gt;
#else

#include &lt;utility&gt;
#include &lt;array&gt;
#include &lt;bits/uses_allocator.h&gt;
#include &lt;bits/invoke.h&gt;

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   *  @addtogroup utilities
   *  @{
   */

  template&lt;typename... _Elements&gt;
    class tuple;

  template&lt;typename _Tp&gt;
    struct __is_empty_non_tuple : is_empty&lt;_Tp&gt; { };

  // Using EBO for elements that are tuples causes ambiguous base errors.
  template&lt;typename _El0, typename... _El&gt;
    struct __is_empty_non_tuple&lt;tuple&lt;_El0, _El...&gt;&gt; : false_type { };

  // Use the Empty Base-class Optimization for empty, non-final types.
  template&lt;typename _Tp&gt;
    using __empty_not_final
    = typename conditional&lt;__is_final(_Tp), false_type,
			   __is_empty_non_tuple&lt;_Tp&gt;&gt;::type;

  template&lt;std::size_t _Idx, typename _Head,
	   bool = __empty_not_final&lt;_Head&gt;::value&gt;
    struct _Head_base;

  template&lt;std::size_t _Idx, typename _Head&gt;
    struct _Head_base&lt;_Idx, _Head, true&gt;
    : public _Head
    {
      constexpr _Head_base()
      : _Head() { }

      constexpr _Head_base(const _Head&amp; __h)
      : _Head(__h) { }

      constexpr _Head_base(const _Head_base&amp;) = default;
      constexpr _Head_base(_Head_base&amp;&amp;) = default;

      template&lt;typename _UHead&gt;
        constexpr _Head_base(_UHead&amp;&amp; __h)
	: _Head(std::forward&lt;_UHead&gt;(__h)) { }

      _Head_base(allocator_arg_t, __uses_alloc0)
      : _Head() { }

      template&lt;typename _Alloc&gt;
	_Head_base(allocator_arg_t, __uses_alloc1&lt;_Alloc&gt; __a)
	: _Head(allocator_arg, *__a._M_a) { }

      template&lt;typename _Alloc&gt;
	_Head_base(allocator_arg_t, __uses_alloc2&lt;_Alloc&gt; __a)
	: _Head(*__a._M_a) { }

      template&lt;typename _UHead&gt;
	_Head_base(__uses_alloc0, _UHead&amp;&amp; __uhead)
	: _Head(std::forward&lt;_UHead&gt;(__uhead)) { }

      template&lt;typename _Alloc, typename _UHead&gt;
	_Head_base(__uses_alloc1&lt;_Alloc&gt; __a, _UHead&amp;&amp; __uhead)
	: _Head(allocator_arg, *__a._M_a, std::forward&lt;_UHead&gt;(__uhead)) { }

      template&lt;typename _Alloc, typename _UHead&gt;
	_Head_base(__uses_alloc2&lt;_Alloc&gt; __a, _UHead&amp;&amp; __uhead)
	: _Head(std::forward&lt;_UHead&gt;(__uhead), *__a._M_a) { }

      static constexpr _Head&amp;
      _M_head(_Head_base&amp; __b) noexcept { return __b; }

      static constexpr const _Head&amp;
      _M_head(const _Head_base&amp; __b) noexcept { return __b; }
    };

  template&lt;std::size_t _Idx, typename _Head&gt;
    struct _Head_base&lt;_Idx, _Head, false&gt;
    {
      constexpr _Head_base()
      : _M_head_impl() { }

      constexpr _Head_base(const _Head&amp; __h)
      : _M_head_impl(__h) { }

      constexpr _Head_base(const _Head_base&amp;) = default;
      constexpr _Head_base(_Head_base&amp;&amp;) = default;

      template&lt;typename _UHead&gt;
        constexpr _Head_base(_UHead&amp;&amp; __h)
	: _M_head_impl(std::forward&lt;_UHead&gt;(__h)) { }

      _Head_base(allocator_arg_t, __uses_alloc0)
      : _M_head_impl() { }

      template&lt;typename _Alloc&gt;
	_Head_base(allocator_arg_t, __uses_alloc1&lt;_Alloc&gt; __a)
	: _M_head_impl(allocator_arg, *__a._M_a) { }

      template&lt;typename _Alloc&gt;
	_Head_base(allocator_arg_t, __uses_alloc2&lt;_Alloc&gt; __a)
	: _M_head_impl(*__a._M_a) { }

      template&lt;typename _UHead&gt;
	_Head_base(__uses_alloc0, _UHead&amp;&amp; __uhead)
	: _M_head_impl(std::forward&lt;_UHead&gt;(__uhead)) { }

      template&lt;typename _Alloc, typename _UHead&gt;
	_Head_base(__uses_alloc1&lt;_Alloc&gt; __a, _UHead&amp;&amp; __uhead)
	: _M_head_impl(allocator_arg, *__a._M_a, std::forward&lt;_UHead&gt;(__uhead))
	{ }

      template&lt;typename _Alloc, typename _UHead&gt;
	_Head_base(__uses_alloc2&lt;_Alloc&gt; __a, _UHead&amp;&amp; __uhead)
	: _M_head_impl(std::forward&lt;_UHead&gt;(__uhead), *__a._M_a) { }

      static constexpr _Head&amp;
      _M_head(_Head_base&amp; __b) noexcept { return __b._M_head_impl; }

      static constexpr const _Head&amp;
      _M_head(const _Head_base&amp; __b) noexcept { return __b._M_head_impl; }

      _Head _M_head_impl;
    };

  /**
   * Contains the actual implementation of the @c tuple template, stored
   * as a recursive inheritance hierarchy from the first element (most
   * derived class) to the last (least derived class). The @c Idx
   * parameter gives the 0-based index of the element stored at this
   * point in the hierarchy; we use it to implement a constant-time
   * get() operation.
   */
  template&lt;std::size_t _Idx, typename... _Elements&gt;
    struct _Tuple_impl;

  /**
   * Recursive tuple implementation. Here we store the @c Head element
   * and derive from a @c Tuple_impl containing the remaining elements
   * (which contains the @c Tail).
   */
  template&lt;std::size_t _Idx, typename _Head, typename... _Tail&gt;
    struct _Tuple_impl&lt;_Idx, _Head, _Tail...&gt;
    : public _Tuple_impl&lt;_Idx + 1, _Tail...&gt;,
      private _Head_base&lt;_Idx, _Head&gt;
    {
      template&lt;std::size_t, typename...&gt; friend class _Tuple_impl;

      typedef _Tuple_impl&lt;_Idx + 1, _Tail...&gt; _Inherited;
      typedef _Head_base&lt;_Idx, _Head&gt; _Base;

      static constexpr _Head&amp;
      _M_head(_Tuple_impl&amp; __t) noexcept { return _Base::_M_head(__t); }

      static constexpr const _Head&amp;
      _M_head(const _Tuple_impl&amp; __t) noexcept { return _Base::_M_head(__t); }

      static constexpr _Inherited&amp;
      _M_tail(_Tuple_impl&amp; __t) noexcept { return __t; }

      static constexpr const _Inherited&amp;
      _M_tail(const _Tuple_impl&amp; __t) noexcept { return __t; }

      constexpr _Tuple_impl()
      : _Inherited(), _Base() { }

      explicit
      constexpr _Tuple_impl(const _Head&amp; __head, const _Tail&amp;... __tail)
      : _Inherited(__tail...), _Base(__head) { }

      template&lt;typename _UHead, typename... _UTail, typename = typename
               enable_if&lt;sizeof...(_Tail) == sizeof...(_UTail)&gt;::type&gt;
        explicit
        constexpr _Tuple_impl(_UHead&amp;&amp; __head, _UTail&amp;&amp;... __tail)
	: _Inherited(std::forward&lt;_UTail&gt;(__tail)...),
	  _Base(std::forward&lt;_UHead&gt;(__head)) { }

      constexpr _Tuple_impl(const _Tuple_impl&amp;) = default;

      constexpr
      _Tuple_impl(_Tuple_impl&amp;&amp; __in)
      noexcept(__and_&lt;is_nothrow_move_constructible&lt;_Head&gt;,
	              is_nothrow_move_constructible&lt;_Inherited&gt;&gt;::value)
      : _Inherited(std::move(_M_tail(__in))),
	_Base(std::forward&lt;_Head&gt;(_M_head(__in))) { }

      template&lt;typename... _UElements&gt;
        constexpr _Tuple_impl(const _Tuple_impl&lt;_Idx, _UElements...&gt;&amp; __in)
	: _Inherited(_Tuple_impl&lt;_Idx, _UElements...&gt;::_M_tail(__in)),
	  _Base(_Tuple_impl&lt;_Idx, _UElements...&gt;::_M_head(__in)) { }

      template&lt;typename _UHead, typename... _UTails&gt;
        constexpr _Tuple_impl(_Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;&amp;&amp; __in)
	: _Inherited(std::move
		     (_Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;::_M_tail(__in))),
	  _Base(std::forward&lt;_UHead&gt;
		(_Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;::_M_head(__in))) { }

      template&lt;typename _Alloc&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a)
	: _Inherited(__tag, __a),
          _Base(__tag, __use_alloc&lt;_Head&gt;(__a)) { }

      template&lt;typename _Alloc&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
		    const _Head&amp; __head, const _Tail&amp;... __tail)
	: _Inherited(__tag, __a, __tail...),
          _Base(__use_alloc&lt;_Head, _Alloc, _Head&gt;(__a), __head) { }

      template&lt;typename _Alloc, typename _UHead, typename... _UTail,
               typename = typename enable_if&lt;sizeof...(_Tail)
					     == sizeof...(_UTail)&gt;::type&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
	            _UHead&amp;&amp; __head, _UTail&amp;&amp;... __tail)
	: _Inherited(__tag, __a, std::forward&lt;_UTail&gt;(__tail)...),
          _Base(__use_alloc&lt;_Head, _Alloc, _UHead&gt;(__a),
	        std::forward&lt;_UHead&gt;(__head)) { }

      template&lt;typename _Alloc&gt;
        _Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
	            const _Tuple_impl&amp; __in)
	: _Inherited(__tag, __a, _M_tail(__in)),
          _Base(__use_alloc&lt;_Head, _Alloc, _Head&gt;(__a), _M_head(__in)) { }

      template&lt;typename _Alloc&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
	            _Tuple_impl&amp;&amp; __in)
	: _Inherited(__tag, __a, std::move(_M_tail(__in))),
	  _Base(__use_alloc&lt;_Head, _Alloc, _Head&gt;(__a),
	        std::forward&lt;_Head&gt;(_M_head(__in))) { }

      template&lt;typename _Alloc, typename _UHead, typename... _UTails&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
		    const _Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;&amp; __in)
	: _Inherited(__tag, __a,
		     _Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;::_M_tail(__in)),
	  _Base(__use_alloc&lt;_Head, _Alloc, const _UHead&amp;&gt;(__a),
		_Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;::_M_head(__in)) { }

      template&lt;typename _Alloc, typename _UHead, typename... _UTails&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
	            _Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;&amp;&amp; __in)
	: _Inherited(__tag, __a, std::move
		     (_Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;::_M_tail(__in))),
	  _Base(__use_alloc&lt;_Head, _Alloc, _UHead&gt;(__a),
                std::forward&lt;_UHead&gt;
		(_Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;::_M_head(__in))) { }

      _Tuple_impl&amp;
      operator=(const _Tuple_impl&amp; __in)
      {
	_M_head(*this) = _M_head(__in);
	_M_tail(*this) = _M_tail(__in);
	return *this;
      }

      _Tuple_impl&amp;
      operator=(_Tuple_impl&amp;&amp; __in)
      noexcept(__and_&lt;is_nothrow_move_assignable&lt;_Head&gt;,
	              is_nothrow_move_assignable&lt;_Inherited&gt;&gt;::value)
      {
	_M_head(*this) = std::forward&lt;_Head&gt;(_M_head(__in));
	_M_tail(*this) = std::move(_M_tail(__in));
	return *this;
      }

      template&lt;typename... _UElements&gt;
        _Tuple_impl&amp;
        operator=(const _Tuple_impl&lt;_Idx, _UElements...&gt;&amp; __in)
        {
	  _M_head(*this) = _Tuple_impl&lt;_Idx, _UElements...&gt;::_M_head(__in);
	  _M_tail(*this) = _Tuple_impl&lt;_Idx, _UElements...&gt;::_M_tail(__in);
	  return *this;
	}

      template&lt;typename _UHead, typename... _UTails&gt;
        _Tuple_impl&amp;
        operator=(_Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;&amp;&amp; __in)
        {
	  _M_head(*this) = std::forward&lt;_UHead&gt;
	    (_Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;::_M_head(__in));
	  _M_tail(*this) = std::move
	    (_Tuple_impl&lt;_Idx, _UHead, _UTails...&gt;::_M_tail(__in));
	  return *this;
	}

    protected:
      void
      _M_swap(_Tuple_impl&amp; __in)
      noexcept(__is_nothrow_swappable&lt;_Head&gt;::value
               &amp;&amp; noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
      {
	using std::swap;
	swap(_M_head(*this), _M_head(__in));
	_Inherited::_M_swap(_M_tail(__in));
      }
    };

  // Basis case of inheritance recursion.
  template&lt;std::size_t _Idx, typename _Head&gt;
    struct _Tuple_impl&lt;_Idx, _Head&gt;
    : private _Head_base&lt;_Idx, _Head&gt;
    {
      template&lt;std::size_t, typename...&gt; friend class _Tuple_impl;

      typedef _Head_base&lt;_Idx, _Head&gt; _Base;

      static constexpr _Head&amp;
      _M_head(_Tuple_impl&amp; __t) noexcept { return _Base::_M_head(__t); }

      static constexpr const _Head&amp;
      _M_head(const _Tuple_impl&amp; __t) noexcept { return _Base::_M_head(__t); }

      constexpr _Tuple_impl()
      : _Base() { }

      explicit
      constexpr _Tuple_impl(const _Head&amp; __head)
      : _Base(__head) { }

      template&lt;typename _UHead&gt;
        explicit
        constexpr _Tuple_impl(_UHead&amp;&amp; __head)
	: _Base(std::forward&lt;_UHead&gt;(__head)) { }

      constexpr _Tuple_impl(const _Tuple_impl&amp;) = default;

      constexpr
      _Tuple_impl(_Tuple_impl&amp;&amp; __in)
      noexcept(is_nothrow_move_constructible&lt;_Head&gt;::value)
      : _Base(std::forward&lt;_Head&gt;(_M_head(__in))) { }

      template&lt;typename _UHead&gt;
        constexpr _Tuple_impl(const _Tuple_impl&lt;_Idx, _UHead&gt;&amp; __in)
	: _Base(_Tuple_impl&lt;_Idx, _UHead&gt;::_M_head(__in)) { }

      template&lt;typename _UHead&gt;
        constexpr _Tuple_impl(_Tuple_impl&lt;_Idx, _UHead&gt;&amp;&amp; __in)
	: _Base(std::forward&lt;_UHead&gt;(_Tuple_impl&lt;_Idx, _UHead&gt;::_M_head(__in)))
	{ }

      template&lt;typename _Alloc&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a)
	: _Base(__tag, __use_alloc&lt;_Head&gt;(__a)) { }

      template&lt;typename _Alloc&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
		    const _Head&amp; __head)
	: _Base(__use_alloc&lt;_Head, _Alloc, _Head&gt;(__a), __head) { }

      template&lt;typename _Alloc, typename _UHead&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
	            _UHead&amp;&amp; __head)
	: _Base(__use_alloc&lt;_Head, _Alloc, _UHead&gt;(__a),
	        std::forward&lt;_UHead&gt;(__head)) { }

      template&lt;typename _Alloc&gt;
        _Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
	            const _Tuple_impl&amp; __in)
	: _Base(__use_alloc&lt;_Head, _Alloc, _Head&gt;(__a), _M_head(__in)) { }

      template&lt;typename _Alloc&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
	            _Tuple_impl&amp;&amp; __in)
	: _Base(__use_alloc&lt;_Head, _Alloc, _Head&gt;(__a),
	        std::forward&lt;_Head&gt;(_M_head(__in))) { }

      template&lt;typename _Alloc, typename _UHead&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
	            const _Tuple_impl&lt;_Idx, _UHead&gt;&amp; __in)
	: _Base(__use_alloc&lt;_Head, _Alloc, const _UHead&amp;&gt;(__a),
		_Tuple_impl&lt;_Idx, _UHead&gt;::_M_head(__in)) { }

      template&lt;typename _Alloc, typename _UHead&gt;
	_Tuple_impl(allocator_arg_t __tag, const _Alloc&amp; __a,
	            _Tuple_impl&lt;_Idx, _UHead&gt;&amp;&amp; __in)
	: _Base(__use_alloc&lt;_Head, _Alloc, _UHead&gt;(__a),
                std::forward&lt;_UHead&gt;(_Tuple_impl&lt;_Idx, _UHead&gt;::_M_head(__in)))
	{ }

      _Tuple_impl&amp;
      operator=(const _Tuple_impl&amp; __in)
      {
	_M_head(*this) = _M_head(__in);
	return *this;
      }

      _Tuple_impl&amp;
      operator=(_Tuple_impl&amp;&amp; __in)
      noexcept(is_nothrow_move_assignable&lt;_Head&gt;::value)
      {
	_M_head(*this) = std::forward&lt;_Head&gt;(_M_head(__in));
	return *this;
      }

      template&lt;typename _UHead&gt;
        _Tuple_impl&amp;
        operator=(const _Tuple_impl&lt;_Idx, _UHead&gt;&amp; __in)
        {
	  _M_head(*this) = _Tuple_impl&lt;_Idx, _UHead&gt;::_M_head(__in);
	  return *this;
	}

      template&lt;typename _UHead&gt;
        _Tuple_impl&amp;
        operator=(_Tuple_impl&lt;_Idx, _UHead&gt;&amp;&amp; __in)
        {
	  _M_head(*this)
	    = std::forward&lt;_UHead&gt;(_Tuple_impl&lt;_Idx, _UHead&gt;::_M_head(__in));
	  return *this;
	}

    protected:
      void
      _M_swap(_Tuple_impl&amp; __in)
      noexcept(__is_nothrow_swappable&lt;_Head&gt;::value)
      {
	using std::swap;
	swap(_M_head(*this), _M_head(__in));
      }
    };

  // Concept utility functions, reused in conditionally-explicit
  // constructors.
  template&lt;bool, typename... _Elements&gt;
  struct _TC
  {
    template&lt;typename... _UElements&gt;
    static constexpr bool _ConstructibleTuple()
    {
      return __and_&lt;is_constructible&lt;_Elements, const _UElements&amp;&gt;...&gt;::value;
    }

    template&lt;typename... _UElements&gt;
    static constexpr bool _ImplicitlyConvertibleTuple()
    {
      return __and_&lt;is_convertible&lt;const _UElements&amp;, _Elements&gt;...&gt;::value;
    }

    template&lt;typename... _UElements&gt;
    static constexpr bool _MoveConstructibleTuple()
    {
      return __and_&lt;is_constructible&lt;_Elements, _UElements&amp;&amp;&gt;...&gt;::value;
    }

    template&lt;typename... _UElements&gt;
    static constexpr bool _ImplicitlyMoveConvertibleTuple()
    {
      return __and_&lt;is_convertible&lt;_UElements&amp;&amp;, _Elements&gt;...&gt;::value;
    }

    template&lt;typename _SrcTuple&gt;
    static constexpr bool _NonNestedTuple()
    {
      return  __and_&lt;__not_&lt;is_same&lt;tuple&lt;_Elements...&gt;,
                                   typename remove_cv&lt;
                                     typename remove_reference&lt;_SrcTuple&gt;::type
                                   &gt;::type&gt;&gt;,
                     __not_&lt;is_convertible&lt;_SrcTuple, _Elements...&gt;&gt;,
                     __not_&lt;is_constructible&lt;_Elements..., _SrcTuple&gt;&gt;
              &gt;::value;
    }
    template&lt;typename... _UElements&gt;
    static constexpr bool _NotSameTuple()
    {
      return  __not_&lt;is_same&lt;tuple&lt;_Elements...&gt;,
			     typename remove_const&lt;
			       typename remove_reference&lt;_UElements...&gt;::type
			       &gt;::type&gt;&gt;::value;
    }
  };

  template&lt;typename... _Elements&gt;
  struct _TC&lt;false, _Elements...&gt;
  {
    template&lt;typename... _UElements&gt;
    static constexpr bool _ConstructibleTuple()
    {
      return false;
    }

    template&lt;typename... _UElements&gt;
    static constexpr bool _ImplicitlyConvertibleTuple()
    {
      return false;
    }

    template&lt;typename... _UElements&gt;
    static constexpr bool _MoveConstructibleTuple()
    {
      return false;
    }

    template&lt;typename... _UElements&gt;
    static constexpr bool _ImplicitlyMoveConvertibleTuple()
    {
      return false;
    }

    template&lt;typename... _UElements&gt;
    static constexpr bool _NonNestedTuple()
    {
      return true;
    }
    template&lt;typename... _UElements&gt;
    static constexpr bool _NotSameTuple()
    {
      return  true;
    }
  };

  /// Primary class template, tuple
  template&lt;typename... _Elements&gt;
    class tuple : public _Tuple_impl&lt;0, _Elements...&gt;
    {
      typedef _Tuple_impl&lt;0, _Elements...&gt; _Inherited;

      // Used for constraining the default constructor so
      // that it becomes dependent on the constraints.
      template&lt;typename _Dummy&gt;
      struct _TC2
      {
        static constexpr bool _DefaultConstructibleTuple()
        {
          return __and_&lt;is_default_constructible&lt;_Elements&gt;...&gt;::value;
        }
        static constexpr bool _ImplicitlyDefaultConstructibleTuple()
        {
          return __and_&lt;__is_implicitly_default_constructible&lt;_Elements&gt;...&gt;
            ::value;
        }
      };

    public:
      template&lt;typename _Dummy = void,
               typename enable_if&lt;_TC2&lt;_Dummy&gt;::
                                    _ImplicitlyDefaultConstructibleTuple(),
                                  bool&gt;::type = true&gt;
      constexpr tuple()
      : _Inherited() { }

      template&lt;typename _Dummy = void,
               typename enable_if&lt;_TC2&lt;_Dummy&gt;::
                                    _DefaultConstructibleTuple()
                                  &amp;&amp;
                                  !_TC2&lt;_Dummy&gt;::
                                    _ImplicitlyDefaultConstructibleTuple(),
                                  bool&gt;::type = false&gt;
      explicit constexpr tuple()
      : _Inherited() { }

      // Shortcut for the cases where constructors taking _Elements...
      // need to be constrained.
      template&lt;typename _Dummy&gt; using _TCC =
        _TC&lt;is_same&lt;_Dummy, void&gt;::value,
            _Elements...&gt;;

      template&lt;typename _Dummy = void,
               typename enable_if&lt;
                 _TCC&lt;_Dummy&gt;::template
                   _ConstructibleTuple&lt;_Elements...&gt;()
                 &amp;&amp; _TCC&lt;_Dummy&gt;::template
                   _ImplicitlyConvertibleTuple&lt;_Elements...&gt;()
                 &amp;&amp; (sizeof...(_Elements) &gt;= 1),
               bool&gt;::type=true&gt;
        constexpr tuple(const _Elements&amp;... __elements)
      : _Inherited(__elements...) { }

      template&lt;typename _Dummy = void,
               typename enable_if&lt;
                 _TCC&lt;_Dummy&gt;::template
                   _ConstructibleTuple&lt;_Elements...&gt;()
                 &amp;&amp; !_TCC&lt;_Dummy&gt;::template
                   _ImplicitlyConvertibleTuple&lt;_Elements...&gt;()
                 &amp;&amp; (sizeof...(_Elements) &gt;= 1),
               bool&gt;::type=false&gt;
      explicit constexpr tuple(const _Elements&amp;... __elements)
      : _Inherited(__elements...) { }

      // Shortcut for the cases where constructors taking _UElements...
      // need to be constrained.
      template&lt;typename... _UElements&gt; using _TMC =
                  _TC&lt;(sizeof...(_Elements) == sizeof...(_UElements))
		      &amp;&amp; (_TC&lt;(sizeof...(_UElements)==1), _Elements...&gt;::
			  template _NotSameTuple&lt;_UElements...&gt;()),
                      _Elements...&gt;;

      // Shortcut for the cases where constructors taking tuple&lt;_UElements...&gt;
      // need to be constrained.
      template&lt;typename... _UElements&gt; using _TMCT =
                  _TC&lt;(sizeof...(_Elements) == sizeof...(_UElements))
		      &amp;&amp; !is_same&lt;tuple&lt;_Elements...&gt;,
				  tuple&lt;_UElements...&gt;&gt;::value,
                      _Elements...&gt;;

      template&lt;typename... _UElements, typename
	       enable_if&lt;
		  _TMC&lt;_UElements...&gt;::template
                    _MoveConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TMC&lt;_UElements...&gt;::template
                    _ImplicitlyMoveConvertibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; (sizeof...(_Elements) &gt;= 1),
        bool&gt;::type=true&gt;
        constexpr tuple(_UElements&amp;&amp;... __elements)
        : _Inherited(std::forward&lt;_UElements&gt;(__elements)...) { }

      template&lt;typename... _UElements, typename
        enable_if&lt;
		  _TMC&lt;_UElements...&gt;::template
                    _MoveConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; !_TMC&lt;_UElements...&gt;::template
                    _ImplicitlyMoveConvertibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; (sizeof...(_Elements) &gt;= 1),
        bool&gt;::type=false&gt;
        explicit constexpr tuple(_UElements&amp;&amp;... __elements)
	: _Inherited(std::forward&lt;_UElements&gt;(__elements)...) {	}

      constexpr tuple(const tuple&amp;) = default;

      constexpr tuple(tuple&amp;&amp;) = default;

      // Shortcut for the cases where constructors taking tuples
      // must avoid creating temporaries.
      template&lt;typename _Dummy&gt; using _TNTC =
        _TC&lt;is_same&lt;_Dummy, void&gt;::value &amp;&amp; sizeof...(_Elements) == 1,
            _Elements...&gt;;

      template&lt;typename... _UElements, typename _Dummy = void, typename
        enable_if&lt;_TMCT&lt;_UElements...&gt;::template
                    _ConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TMCT&lt;_UElements...&gt;::template
                    _ImplicitlyConvertibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TNTC&lt;_Dummy&gt;::template
                    _NonNestedTuple&lt;const tuple&lt;_UElements...&gt;&amp;&gt;(),
        bool&gt;::type=true&gt;
        constexpr tuple(const tuple&lt;_UElements...&gt;&amp; __in)
        : _Inherited(static_cast&lt;const _Tuple_impl&lt;0, _UElements...&gt;&amp;&gt;(__in))
        { }

      template&lt;typename... _UElements, typename _Dummy = void, typename
        enable_if&lt;_TMCT&lt;_UElements...&gt;::template
                    _ConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; !_TMCT&lt;_UElements...&gt;::template
                    _ImplicitlyConvertibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TNTC&lt;_Dummy&gt;::template
                    _NonNestedTuple&lt;const tuple&lt;_UElements...&gt;&amp;&gt;(),
        bool&gt;::type=false&gt;
        explicit constexpr tuple(const tuple&lt;_UElements...&gt;&amp; __in)
        : _Inherited(static_cast&lt;const _Tuple_impl&lt;0, _UElements...&gt;&amp;&gt;(__in))
        { }

      template&lt;typename... _UElements, typename _Dummy = void, typename
        enable_if&lt;_TMCT&lt;_UElements...&gt;::template
                    _MoveConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TMCT&lt;_UElements...&gt;::template
                    _ImplicitlyMoveConvertibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TNTC&lt;_Dummy&gt;::template
                    _NonNestedTuple&lt;tuple&lt;_UElements...&gt;&amp;&amp;&gt;(),
        bool&gt;::type=true&gt;
        constexpr tuple(tuple&lt;_UElements...&gt;&amp;&amp; __in)
        : _Inherited(static_cast&lt;_Tuple_impl&lt;0, _UElements...&gt;&amp;&amp;&gt;(__in)) { }

      template&lt;typename... _UElements, typename _Dummy = void, typename
        enable_if&lt;_TMCT&lt;_UElements...&gt;::template
                    _MoveConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; !_TMCT&lt;_UElements...&gt;::template
                    _ImplicitlyMoveConvertibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TNTC&lt;_Dummy&gt;::template
                    _NonNestedTuple&lt;tuple&lt;_UElements...&gt;&amp;&amp;&gt;(),
        bool&gt;::type=false&gt;
        explicit constexpr tuple(tuple&lt;_UElements...&gt;&amp;&amp; __in)
        : _Inherited(static_cast&lt;_Tuple_impl&lt;0, _UElements...&gt;&amp;&amp;&gt;(__in)) { }

      // Allocator-extended constructors.

      template&lt;typename _Alloc&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a)
	: _Inherited(__tag, __a) { }

      template&lt;typename _Alloc, typename _Dummy = void,
               typename enable_if&lt;
                 _TCC&lt;_Dummy&gt;::template
                   _ConstructibleTuple&lt;_Elements...&gt;()
                 &amp;&amp; _TCC&lt;_Dummy&gt;::template
                   _ImplicitlyConvertibleTuple&lt;_Elements...&gt;(),
               bool&gt;::type=true&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      const _Elements&amp;... __elements)
	: _Inherited(__tag, __a, __elements...) { }

      template&lt;typename _Alloc, typename _Dummy = void,
               typename enable_if&lt;
                 _TCC&lt;_Dummy&gt;::template
                   _ConstructibleTuple&lt;_Elements...&gt;()
                 &amp;&amp; !_TCC&lt;_Dummy&gt;::template
                   _ImplicitlyConvertibleTuple&lt;_Elements...&gt;(),
               bool&gt;::type=false&gt;
	explicit tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
                       const _Elements&amp;... __elements)
	: _Inherited(__tag, __a, __elements...) { }

      template&lt;typename _Alloc, typename... _UElements, typename
        enable_if&lt;_TMC&lt;_UElements...&gt;::template
                    _MoveConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TMC&lt;_UElements...&gt;::template
                    _ImplicitlyMoveConvertibleTuple&lt;_UElements...&gt;(),
        bool&gt;::type=true&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      _UElements&amp;&amp;... __elements)
	: _Inherited(__tag, __a, std::forward&lt;_UElements&gt;(__elements)...)
       	{ }

      template&lt;typename _Alloc, typename... _UElements, typename
        enable_if&lt;_TMC&lt;_UElements...&gt;::template
                    _MoveConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; !_TMC&lt;_UElements...&gt;::template
                    _ImplicitlyMoveConvertibleTuple&lt;_UElements...&gt;(),
        bool&gt;::type=false&gt;
	explicit tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      _UElements&amp;&amp;... __elements)
	: _Inherited(__tag, __a, std::forward&lt;_UElements&gt;(__elements)...)
        { }

      template&lt;typename _Alloc&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a, const tuple&amp; __in)
	: _Inherited(__tag, __a, static_cast&lt;const _Inherited&amp;&gt;(__in)) { }

      template&lt;typename _Alloc&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a, tuple&amp;&amp; __in)
	: _Inherited(__tag, __a, static_cast&lt;_Inherited&amp;&amp;&gt;(__in)) { }

      template&lt;typename _Alloc, typename _Dummy = void,
	       typename... _UElements, typename
        enable_if&lt;_TMCT&lt;_UElements...&gt;::template
                    _ConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TMCT&lt;_UElements...&gt;::template
                    _ImplicitlyConvertibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TNTC&lt;_Dummy&gt;::template
                    _NonNestedTuple&lt;tuple&lt;_UElements...&gt;&amp;&amp;&gt;(),
        bool&gt;::type=true&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      const tuple&lt;_UElements...&gt;&amp; __in)
	: _Inherited(__tag, __a,
	             static_cast&lt;const _Tuple_impl&lt;0, _UElements...&gt;&amp;&gt;(__in))
	{ }

      template&lt;typename _Alloc, typename _Dummy = void,
	       typename... _UElements, typename
        enable_if&lt;_TMCT&lt;_UElements...&gt;::template
                    _ConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; !_TMCT&lt;_UElements...&gt;::template
                    _ImplicitlyConvertibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TNTC&lt;_Dummy&gt;::template
                    _NonNestedTuple&lt;tuple&lt;_UElements...&gt;&amp;&amp;&gt;(),
        bool&gt;::type=false&gt;
	explicit tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      const tuple&lt;_UElements...&gt;&amp; __in)
	: _Inherited(__tag, __a,
	             static_cast&lt;const _Tuple_impl&lt;0, _UElements...&gt;&amp;&gt;(__in))
	{ }

      template&lt;typename _Alloc, typename _Dummy = void,
	       typename... _UElements, typename
        enable_if&lt;_TMCT&lt;_UElements...&gt;::template
                    _MoveConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TMCT&lt;_UElements...&gt;::template
                    _ImplicitlyMoveConvertibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TNTC&lt;_Dummy&gt;::template
                    _NonNestedTuple&lt;tuple&lt;_UElements...&gt;&amp;&amp;&gt;(),
        bool&gt;::type=true&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      tuple&lt;_UElements...&gt;&amp;&amp; __in)
	: _Inherited(__tag, __a,
	             static_cast&lt;_Tuple_impl&lt;0, _UElements...&gt;&amp;&amp;&gt;(__in))
	{ }

      template&lt;typename _Alloc, typename _Dummy = void,
	       typename... _UElements, typename
        enable_if&lt;_TMCT&lt;_UElements...&gt;::template
                    _MoveConstructibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; !_TMCT&lt;_UElements...&gt;::template
                    _ImplicitlyMoveConvertibleTuple&lt;_UElements...&gt;()
                  &amp;&amp; _TNTC&lt;_Dummy&gt;::template
                    _NonNestedTuple&lt;tuple&lt;_UElements...&gt;&amp;&amp;&gt;(),
        bool&gt;::type=false&gt;
	explicit tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      tuple&lt;_UElements...&gt;&amp;&amp; __in)
	: _Inherited(__tag, __a,
	             static_cast&lt;_Tuple_impl&lt;0, _UElements...&gt;&amp;&amp;&gt;(__in))
	{ }

      tuple&amp;
      operator=(const tuple&amp; __in)
      {
	static_cast&lt;_Inherited&amp;&gt;(*this) = __in;
	return *this;
      }

      tuple&amp;
      operator=(tuple&amp;&amp; __in)
      noexcept(is_nothrow_move_assignable&lt;_Inherited&gt;::value)
      {
	static_cast&lt;_Inherited&amp;&gt;(*this) = std::move(__in);
	return *this;
      }

      template&lt;typename... _UElements&gt;
	typename
	       enable_if&lt;sizeof...(_UElements)
			 == sizeof...(_Elements), tuple&amp;&gt;::type
        operator=(const tuple&lt;_UElements...&gt;&amp; __in)
        {
	  static_cast&lt;_Inherited&amp;&gt;(*this) = __in;
	  return *this;
	}

      template&lt;typename... _UElements&gt;
	typename
	       enable_if&lt;sizeof...(_UElements)
			 == sizeof...(_Elements), tuple&amp;&gt;::type
        operator=(tuple&lt;_UElements...&gt;&amp;&amp; __in)
        {
	  static_cast&lt;_Inherited&amp;&gt;(*this) = std::move(__in);
	  return *this;
	}

      void
      swap(tuple&amp; __in)
      noexcept(noexcept(__in._M_swap(__in)))
      { _Inherited::_M_swap(__in); }
    };

#if __cpp_deduction_guides &gt;= 201606
  template&lt;typename... _UTypes&gt;
    tuple(_UTypes...) -&gt; tuple&lt;_UTypes...&gt;;
  template&lt;typename _T1, typename _T2&gt;
    tuple(pair&lt;_T1, _T2&gt;) -&gt; tuple&lt;_T1, _T2&gt;;
  template&lt;typename _Alloc, typename... _UTypes&gt;
    tuple(allocator_arg_t, _Alloc, _UTypes...) -&gt; tuple&lt;_UTypes...&gt;;
  template&lt;typename _Alloc, typename _T1, typename _T2&gt;
    tuple(allocator_arg_t, _Alloc, pair&lt;_T1, _T2&gt;) -&gt; tuple&lt;_T1, _T2&gt;;
  template&lt;typename _Alloc, typename... _UTypes&gt;
    tuple(allocator_arg_t, _Alloc, tuple&lt;_UTypes...&gt;) -&gt; tuple&lt;_UTypes...&gt;;
#endif

  // Explicit specialization, zero-element tuple.
  template&lt;&gt;
    class tuple&lt;&gt;
    {
    public:
      void swap(tuple&amp;) noexcept { /* no-op */ }
      // We need the default since we're going to define no-op
      // allocator constructors.
      tuple() = default;
      // No-op allocator constructors.
      template&lt;typename _Alloc&gt;
	tuple(allocator_arg_t, const _Alloc&amp;) { }
      template&lt;typename _Alloc&gt;
	tuple(allocator_arg_t, const _Alloc&amp;, const tuple&amp;) { }
    };

  /// Partial specialization, 2-element tuple.
  /// Includes construction and assignment from a pair.
  template&lt;typename _T1, typename _T2&gt;
    class tuple&lt;_T1, _T2&gt; : public _Tuple_impl&lt;0, _T1, _T2&gt;
    {
      typedef _Tuple_impl&lt;0, _T1, _T2&gt; _Inherited;

    public:
      template &lt;typename _U1 = _T1,
                typename _U2 = _T2,
                typename enable_if&lt;__and_&lt;
                                     __is_implicitly_default_constructible&lt;_U1&gt;,
                                     __is_implicitly_default_constructible&lt;_U2&gt;&gt;
                                   ::value, bool&gt;::type = true&gt;

      constexpr tuple()
      : _Inherited() { }

      template &lt;typename _U1 = _T1,
                typename _U2 = _T2,
                typename enable_if&lt;
                  __and_&lt;
                    is_default_constructible&lt;_U1&gt;,
                    is_default_constructible&lt;_U2&gt;,
                    __not_&lt;
                      __and_&lt;__is_implicitly_default_constructible&lt;_U1&gt;,
                             __is_implicitly_default_constructible&lt;_U2&gt;&gt;&gt;&gt;
                  ::value, bool&gt;::type = false&gt;

      explicit constexpr tuple()
      : _Inherited() { }

      // Shortcut for the cases where constructors taking _T1, _T2
      // need to be constrained.
      template&lt;typename _Dummy&gt; using _TCC =
        _TC&lt;is_same&lt;_Dummy, void&gt;::value, _T1, _T2&gt;;

      template&lt;typename _Dummy = void, typename
               enable_if&lt;_TCC&lt;_Dummy&gt;::template
                           _ConstructibleTuple&lt;_T1, _T2&gt;()
                         &amp;&amp; _TCC&lt;_Dummy&gt;::template
                           _ImplicitlyConvertibleTuple&lt;_T1, _T2&gt;(),
	bool&gt;::type = true&gt;
        constexpr tuple(const _T1&amp; __a1, const _T2&amp; __a2)
        : _Inherited(__a1, __a2) { }

      template&lt;typename _Dummy = void, typename
               enable_if&lt;_TCC&lt;_Dummy&gt;::template
                           _ConstructibleTuple&lt;_T1, _T2&gt;()
                         &amp;&amp; !_TCC&lt;_Dummy&gt;::template
                           _ImplicitlyConvertibleTuple&lt;_T1, _T2&gt;(),
	bool&gt;::type = false&gt;
        explicit constexpr tuple(const _T1&amp; __a1, const _T2&amp; __a2)
        : _Inherited(__a1, __a2) { }

      // Shortcut for the cases where constructors taking _U1, _U2
      // need to be constrained.
      using _TMC = _TC&lt;true, _T1, _T2&gt;;

      template&lt;typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; _TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;()
	          &amp;&amp; !is_same&lt;typename decay&lt;_U1&gt;::type,
			      allocator_arg_t&gt;::value,
	bool&gt;::type = true&gt;
        constexpr tuple(_U1&amp;&amp; __a1, _U2&amp;&amp; __a2)
	: _Inherited(std::forward&lt;_U1&gt;(__a1), std::forward&lt;_U2&gt;(__a2)) { }

      template&lt;typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; !_TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;()
	          &amp;&amp; !is_same&lt;typename decay&lt;_U1&gt;::type,
			      allocator_arg_t&gt;::value,
	bool&gt;::type = false&gt;
        explicit constexpr tuple(_U1&amp;&amp; __a1, _U2&amp;&amp; __a2)
	: _Inherited(std::forward&lt;_U1&gt;(__a1), std::forward&lt;_U2&gt;(__a2)) { }

      constexpr tuple(const tuple&amp;) = default;

      constexpr tuple(tuple&amp;&amp;) = default;

      template&lt;typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _ConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; _TMC::template
                    _ImplicitlyConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = true&gt;
        constexpr tuple(const tuple&lt;_U1, _U2&gt;&amp; __in)
	: _Inherited(static_cast&lt;const _Tuple_impl&lt;0, _U1, _U2&gt;&amp;&gt;(__in)) { }

      template&lt;typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _ConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; !_TMC::template
                    _ImplicitlyConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = false&gt;
        explicit constexpr tuple(const tuple&lt;_U1, _U2&gt;&amp; __in)
	: _Inherited(static_cast&lt;const _Tuple_impl&lt;0, _U1, _U2&gt;&amp;&gt;(__in)) { }

      template&lt;typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; _TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = true&gt;
        constexpr tuple(tuple&lt;_U1, _U2&gt;&amp;&amp; __in)
	: _Inherited(static_cast&lt;_Tuple_impl&lt;0, _U1, _U2&gt;&amp;&amp;&gt;(__in)) { }

      template&lt;typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; !_TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = false&gt;
        explicit constexpr tuple(tuple&lt;_U1, _U2&gt;&amp;&amp; __in)
	: _Inherited(static_cast&lt;_Tuple_impl&lt;0, _U1, _U2&gt;&amp;&amp;&gt;(__in)) { }

      template&lt;typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _ConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; _TMC::template
                    _ImplicitlyConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = true&gt;
        constexpr tuple(const pair&lt;_U1, _U2&gt;&amp; __in)
	: _Inherited(__in.first, __in.second) { }

      template&lt;typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _ConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; !_TMC::template
                    _ImplicitlyConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = false&gt;
        explicit constexpr tuple(const pair&lt;_U1, _U2&gt;&amp; __in)
	: _Inherited(__in.first, __in.second) { }

      template&lt;typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; _TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = true&gt;
        constexpr tuple(pair&lt;_U1, _U2&gt;&amp;&amp; __in)
	: _Inherited(std::forward&lt;_U1&gt;(__in.first),
		     std::forward&lt;_U2&gt;(__in.second)) { }

      template&lt;typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; !_TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = false&gt;
        explicit constexpr tuple(pair&lt;_U1, _U2&gt;&amp;&amp; __in)
	: _Inherited(std::forward&lt;_U1&gt;(__in.first),
		     std::forward&lt;_U2&gt;(__in.second)) { }

      // Allocator-extended constructors.

      template&lt;typename _Alloc&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a)
	: _Inherited(__tag, __a) { }

      template&lt;typename _Alloc, typename _Dummy = void,
               typename enable_if&lt;
                 _TCC&lt;_Dummy&gt;::template
                   _ConstructibleTuple&lt;_T1, _T2&gt;()
                 &amp;&amp; _TCC&lt;_Dummy&gt;::template
                   _ImplicitlyConvertibleTuple&lt;_T1, _T2&gt;(),
               bool&gt;::type=true&gt;

	tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      const _T1&amp; __a1, const _T2&amp; __a2)
	: _Inherited(__tag, __a, __a1, __a2) { }

      template&lt;typename _Alloc, typename _Dummy = void,
               typename enable_if&lt;
                 _TCC&lt;_Dummy&gt;::template
                   _ConstructibleTuple&lt;_T1, _T2&gt;()
                 &amp;&amp; !_TCC&lt;_Dummy&gt;::template
                   _ImplicitlyConvertibleTuple&lt;_T1, _T2&gt;(),
               bool&gt;::type=false&gt;

	explicit tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      const _T1&amp; __a1, const _T2&amp; __a2)
	: _Inherited(__tag, __a, __a1, __a2) { }

      template&lt;typename _Alloc, typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; _TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = true&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a, _U1&amp;&amp; __a1, _U2&amp;&amp; __a2)
	: _Inherited(__tag, __a, std::forward&lt;_U1&gt;(__a1),
	             std::forward&lt;_U2&gt;(__a2)) { }

      template&lt;typename _Alloc, typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; !_TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = false&gt;
	explicit tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
                       _U1&amp;&amp; __a1, _U2&amp;&amp; __a2)
	: _Inherited(__tag, __a, std::forward&lt;_U1&gt;(__a1),
	             std::forward&lt;_U2&gt;(__a2)) { }

      template&lt;typename _Alloc&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a, const tuple&amp; __in)
	: _Inherited(__tag, __a, static_cast&lt;const _Inherited&amp;&gt;(__in)) { }

      template&lt;typename _Alloc&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a, tuple&amp;&amp; __in)
	: _Inherited(__tag, __a, static_cast&lt;_Inherited&amp;&amp;&gt;(__in)) { }

      template&lt;typename _Alloc, typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _ConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; _TMC::template
                    _ImplicitlyConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = true&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      const tuple&lt;_U1, _U2&gt;&amp; __in)
	: _Inherited(__tag, __a,
	             static_cast&lt;const _Tuple_impl&lt;0, _U1, _U2&gt;&amp;&gt;(__in))
	{ }

      template&lt;typename _Alloc, typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _ConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; !_TMC::template
                    _ImplicitlyConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = false&gt;
	explicit tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      const tuple&lt;_U1, _U2&gt;&amp; __in)
	: _Inherited(__tag, __a,
	             static_cast&lt;const _Tuple_impl&lt;0, _U1, _U2&gt;&amp;&gt;(__in))
	{ }

      template&lt;typename _Alloc, typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; _TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = true&gt;
	tuple(allocator_arg_t __tag, const _Alloc&amp; __a, tuple&lt;_U1, _U2&gt;&amp;&amp; __in)
	: _Inherited(__tag, __a, static_cast&lt;_Tuple_impl&lt;0, _U1, _U2&gt;&amp;&amp;&gt;(__in))
	{ }

      template&lt;typename _Alloc, typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; !_TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = false&gt;
	explicit tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
                       tuple&lt;_U1, _U2&gt;&amp;&amp; __in)
	: _Inherited(__tag, __a, static_cast&lt;_Tuple_impl&lt;0, _U1, _U2&gt;&amp;&amp;&gt;(__in))
	{ }

      template&lt;typename _Alloc, typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _ConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; _TMC::template
                    _ImplicitlyConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = true&gt;
        tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      const pair&lt;_U1, _U2&gt;&amp; __in)
	: _Inherited(__tag, __a, __in.first, __in.second) { }

      template&lt;typename _Alloc, typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _ConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; !_TMC::template
                    _ImplicitlyConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = false&gt;
        explicit tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
	      const pair&lt;_U1, _U2&gt;&amp; __in)
	: _Inherited(__tag, __a, __in.first, __in.second) { }

      template&lt;typename _Alloc, typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; _TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = true&gt;
        tuple(allocator_arg_t __tag, const _Alloc&amp; __a, pair&lt;_U1, _U2&gt;&amp;&amp; __in)
	: _Inherited(__tag, __a, std::forward&lt;_U1&gt;(__in.first),
		     std::forward&lt;_U2&gt;(__in.second)) { }

      template&lt;typename _Alloc, typename _U1, typename _U2, typename
        enable_if&lt;_TMC::template
                    _MoveConstructibleTuple&lt;_U1, _U2&gt;()
                  &amp;&amp; !_TMC::template
                    _ImplicitlyMoveConvertibleTuple&lt;_U1, _U2&gt;(),
	bool&gt;::type = false&gt;
        explicit tuple(allocator_arg_t __tag, const _Alloc&amp; __a,
                       pair&lt;_U1, _U2&gt;&amp;&amp; __in)
	: _Inherited(__tag, __a, std::forward&lt;_U1&gt;(__in.first),
		     std::forward&lt;_U2&gt;(__in.second)) { }

      tuple&amp;
      operator=(const tuple&amp; __in)
      {
	static_cast&lt;_Inherited&amp;&gt;(*this) = __in;
	return *this;
      }

      tuple&amp;
      operator=(tuple&amp;&amp; __in)
      noexcept(is_nothrow_move_assignable&lt;_Inherited&gt;::value)
      {
	static_cast&lt;_Inherited&amp;&gt;(*this) = std::move(__in);
	return *this;
      }

      template&lt;typename _U1, typename _U2&gt;
        tuple&amp;
        operator=(const tuple&lt;_U1, _U2&gt;&amp; __in)
        {
	  static_cast&lt;_Inherited&amp;&gt;(*this) = __in;
	  return *this;
	}

      template&lt;typename _U1, typename _U2&gt;
        tuple&amp;
        operator=(tuple&lt;_U1, _U2&gt;&amp;&amp; __in)
        {
	  static_cast&lt;_Inherited&amp;&gt;(*this) = std::move(__in);
	  return *this;
	}

      template&lt;typename _U1, typename _U2&gt;
        tuple&amp;
        operator=(const pair&lt;_U1, _U2&gt;&amp; __in)
        {
	  this-&gt;_M_head(*this) = __in.first;
	  this-&gt;_M_tail(*this)._M_head(*this) = __in.second;
	  return *this;
	}

      template&lt;typename _U1, typename _U2&gt;
        tuple&amp;
        operator=(pair&lt;_U1, _U2&gt;&amp;&amp; __in)
        {
	  this-&gt;_M_head(*this) = std::forward&lt;_U1&gt;(__in.first);
	  this-&gt;_M_tail(*this)._M_head(*this) = std::forward&lt;_U2&gt;(__in.second);
	  return *this;
	}

      void
      swap(tuple&amp; __in)
      noexcept(noexcept(__in._M_swap(__in)))
      { _Inherited::_M_swap(__in); }
    };


  /// class tuple_size
  template&lt;typename... _Elements&gt;
    struct tuple_size&lt;tuple&lt;_Elements...&gt;&gt;
    : public integral_constant&lt;std::size_t, sizeof...(_Elements)&gt; { };

#if __cplusplus &gt; 201402L
  template &lt;typename _Tp&gt;
    inline constexpr size_t tuple_size_v = tuple_size&lt;_Tp&gt;::value;
#endif

  /**
   * Recursive case for tuple_element: strip off the first element in
   * the tuple and retrieve the (i-1)th element of the remaining tuple.
   */
  template&lt;std::size_t __i, typename _Head, typename... _Tail&gt;
    struct tuple_element&lt;__i, tuple&lt;_Head, _Tail...&gt; &gt;
    : tuple_element&lt;__i - 1, tuple&lt;_Tail...&gt; &gt; { };

  /**
   * Basis case for tuple_element: The first element is the one we're seeking.
   */
  template&lt;typename _Head, typename... _Tail&gt;
    struct tuple_element&lt;0, tuple&lt;_Head, _Tail...&gt; &gt;
    {
      typedef _Head type;
    };

  /**
   * Error case for tuple_element: invalid index.
   */
  template&lt;size_t __i&gt;
    struct tuple_element&lt;__i, tuple&lt;&gt;&gt;
    {
      static_assert(__i &lt; tuple_size&lt;tuple&lt;&gt;&gt;::value,
	  &quot;tuple index is in range&quot;);
    };

  template&lt;std::size_t __i, typename _Head, typename... _Tail&gt;
    constexpr _Head&amp;
    __get_helper(_Tuple_impl&lt;__i, _Head, _Tail...&gt;&amp; __t) noexcept
    { return _Tuple_impl&lt;__i, _Head, _Tail...&gt;::_M_head(__t); }

  template&lt;std::size_t __i, typename _Head, typename... _Tail&gt;
    constexpr const _Head&amp;
    __get_helper(const _Tuple_impl&lt;__i, _Head, _Tail...&gt;&amp; __t) noexcept
    { return _Tuple_impl&lt;__i, _Head, _Tail...&gt;::_M_head(__t); }

  /// Return a reference to the ith element of a tuple.
  template&lt;std::size_t __i, typename... _Elements&gt;
    constexpr __tuple_element_t&lt;__i, tuple&lt;_Elements...&gt;&gt;&amp;
    get(tuple&lt;_Elements...&gt;&amp; __t) noexcept
    { return std::__get_helper&lt;__i&gt;(__t); }

  /// Return a const reference to the ith element of a const tuple.
  template&lt;std::size_t __i, typename... _Elements&gt;
    constexpr const __tuple_element_t&lt;__i, tuple&lt;_Elements...&gt;&gt;&amp;
    get(const tuple&lt;_Elements...&gt;&amp; __t) noexcept
    { return std::__get_helper&lt;__i&gt;(__t); }

  /// Return an rvalue reference to the ith element of a tuple rvalue.
  template&lt;std::size_t __i, typename... _Elements&gt;
    constexpr __tuple_element_t&lt;__i, tuple&lt;_Elements...&gt;&gt;&amp;&amp;
    get(tuple&lt;_Elements...&gt;&amp;&amp; __t) noexcept
    {
      typedef __tuple_element_t&lt;__i, tuple&lt;_Elements...&gt;&gt; __element_type;
      return std::forward&lt;__element_type&amp;&amp;&gt;(std::get&lt;__i&gt;(__t));
    }

  /// Return a const rvalue reference to the ith element of a const tuple rvalue.
  template&lt;std::size_t __i, typename... _Elements&gt;
    constexpr const __tuple_element_t&lt;__i, tuple&lt;_Elements...&gt;&gt;&amp;&amp;
    get(const tuple&lt;_Elements...&gt;&amp;&amp; __t) noexcept
    {
      typedef __tuple_element_t&lt;__i, tuple&lt;_Elements...&gt;&gt; __element_type;
      return std::forward&lt;const __element_type&amp;&amp;&gt;(std::get&lt;__i&gt;(__t));
    }

#if __cplusplus &gt; 201103L

#define __cpp_lib_tuples_by_type 201304

  template&lt;typename _Head, size_t __i, typename... _Tail&gt;
    constexpr _Head&amp;
    __get_helper2(_Tuple_impl&lt;__i, _Head, _Tail...&gt;&amp; __t) noexcept
    { return _Tuple_impl&lt;__i, _Head, _Tail...&gt;::_M_head(__t); }

  template&lt;typename _Head, size_t __i, typename... _Tail&gt;
    constexpr const _Head&amp;
    __get_helper2(const _Tuple_impl&lt;__i, _Head, _Tail...&gt;&amp; __t) noexcept
    { return _Tuple_impl&lt;__i, _Head, _Tail...&gt;::_M_head(__t); }

  /// Return a reference to the unique element of type _Tp of a tuple.
  template &lt;typename _Tp, typename... _Types&gt;
    constexpr _Tp&amp;
    get(tuple&lt;_Types...&gt;&amp; __t) noexcept
    { return std::__get_helper2&lt;_Tp&gt;(__t); }

  /// Return a reference to the unique element of type _Tp of a tuple rvalue.
  template &lt;typename _Tp, typename... _Types&gt;
    constexpr _Tp&amp;&amp;
    get(tuple&lt;_Types...&gt;&amp;&amp; __t) noexcept
    { return std::forward&lt;_Tp&amp;&amp;&gt;(std::__get_helper2&lt;_Tp&gt;(__t)); }

  /// Return a const reference to the unique element of type _Tp of a tuple.
  template &lt;typename _Tp, typename... _Types&gt;
    constexpr const _Tp&amp;
    get(const tuple&lt;_Types...&gt;&amp; __t) noexcept
    { return std::__get_helper2&lt;_Tp&gt;(__t); }

  /// Return a const reference to the unique element of type _Tp of
  /// a const tuple rvalue.
  template &lt;typename _Tp, typename... _Types&gt;
    constexpr const _Tp&amp;&amp;
    get(const tuple&lt;_Types...&gt;&amp;&amp; __t) noexcept
    { return std::forward&lt;const _Tp&amp;&amp;&gt;(std::__get_helper2&lt;_Tp&gt;(__t)); }
#endif

  // This class performs the comparison operations on tuples
  template&lt;typename _Tp, typename _Up, size_t __i, size_t __size&gt;
    struct __tuple_compare
    {
      static constexpr bool
      __eq(const _Tp&amp; __t, const _Up&amp; __u)
      {
	return bool(std::get&lt;__i&gt;(__t) == std::get&lt;__i&gt;(__u))
	  &amp;&amp; __tuple_compare&lt;_Tp, _Up, __i + 1, __size&gt;::__eq(__t, __u);
      }

      static constexpr bool
      __less(const _Tp&amp; __t, const _Up&amp; __u)
      {
	return bool(std::get&lt;__i&gt;(__t) &lt; std::get&lt;__i&gt;(__u))
	  || (!bool(std::get&lt;__i&gt;(__u) &lt; std::get&lt;__i&gt;(__t))
	      &amp;&amp; __tuple_compare&lt;_Tp, _Up, __i + 1, __size&gt;::__less(__t, __u));
      }
    };

  template&lt;typename _Tp, typename _Up, size_t __size&gt;
    struct __tuple_compare&lt;_Tp, _Up, __size, __size&gt;
    {
      static constexpr bool
      __eq(const _Tp&amp;, const _Up&amp;) { return true; }

      static constexpr bool
      __less(const _Tp&amp;, const _Up&amp;) { return false; }
    };

  template&lt;typename... _TElements, typename... _UElements&gt;
    constexpr bool
    operator==(const tuple&lt;_TElements...&gt;&amp; __t,
	       const tuple&lt;_UElements...&gt;&amp; __u)
    {
      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
	  &quot;tuple objects can only be compared if they have equal sizes.&quot;);
      using __compare = __tuple_compare&lt;tuple&lt;_TElements...&gt;,
					tuple&lt;_UElements...&gt;,
					0, sizeof...(_TElements)&gt;;
      return __compare::__eq(__t, __u);
    }

  template&lt;typename... _TElements, typename... _UElements&gt;
    constexpr bool
    operator&lt;(const tuple&lt;_TElements...&gt;&amp; __t,
	      const tuple&lt;_UElements...&gt;&amp; __u)
    {
      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
	  &quot;tuple objects can only be compared if they have equal sizes.&quot;);
      using __compare = __tuple_compare&lt;tuple&lt;_TElements...&gt;,
					tuple&lt;_UElements...&gt;,
					0, sizeof...(_TElements)&gt;;
      return __compare::__less(__t, __u);
    }

  template&lt;typename... _TElements, typename... _UElements&gt;
    constexpr bool
    operator!=(const tuple&lt;_TElements...&gt;&amp; __t,
	       const tuple&lt;_UElements...&gt;&amp; __u)
    { return !(__t == __u); }

  template&lt;typename... _TElements, typename... _UElements&gt;
    constexpr bool
    operator&gt;(const tuple&lt;_TElements...&gt;&amp; __t,
	      const tuple&lt;_UElements...&gt;&amp; __u)
    { return __u &lt; __t; }

  template&lt;typename... _TElements, typename... _UElements&gt;
    constexpr bool
    operator&lt;=(const tuple&lt;_TElements...&gt;&amp; __t,
	       const tuple&lt;_UElements...&gt;&amp; __u)
    { return !(__u &lt; __t); }

  template&lt;typename... _TElements, typename... _UElements&gt;
    constexpr bool
    operator&gt;=(const tuple&lt;_TElements...&gt;&amp; __t,
	       const tuple&lt;_UElements...&gt;&amp; __u)
    { return !(__t &lt; __u); }

  // NB: DR 705.
  template&lt;typename... _Elements&gt;
    constexpr tuple&lt;typename __decay_and_strip&lt;_Elements&gt;::__type...&gt;
    make_tuple(_Elements&amp;&amp;... __args)
    {
      typedef tuple&lt;typename __decay_and_strip&lt;_Elements&gt;::__type...&gt;
	__result_type;
      return __result_type(std::forward&lt;_Elements&gt;(__args)...);
    }

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 2275. Why is forward_as_tuple not constexpr?
  template&lt;typename... _Elements&gt;
    constexpr tuple&lt;_Elements&amp;&amp;...&gt;
    forward_as_tuple(_Elements&amp;&amp;... __args) noexcept
    { return tuple&lt;_Elements&amp;&amp;...&gt;(std::forward&lt;_Elements&gt;(__args)...); }

  template&lt;size_t, typename, typename, size_t&gt;
    struct __make_tuple_impl;

  template&lt;size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm&gt;
    struct __make_tuple_impl&lt;_Idx, tuple&lt;_Tp...&gt;, _Tuple, _Nm&gt;
    : __make_tuple_impl&lt;_Idx + 1,
			tuple&lt;_Tp..., __tuple_element_t&lt;_Idx, _Tuple&gt;&gt;,
			_Tuple, _Nm&gt;
    { };

  template&lt;std::size_t _Nm, typename _Tuple, typename... _Tp&gt;
    struct __make_tuple_impl&lt;_Nm, tuple&lt;_Tp...&gt;, _Tuple, _Nm&gt;
    {
      typedef tuple&lt;_Tp...&gt; __type;
    };

  template&lt;typename _Tuple&gt;
    struct __do_make_tuple
    : __make_tuple_impl&lt;0, tuple&lt;&gt;, _Tuple, std::tuple_size&lt;_Tuple&gt;::value&gt;
    { };

  // Returns the std::tuple equivalent of a tuple-like type.
  template&lt;typename _Tuple&gt;
    struct __make_tuple
    : public __do_make_tuple&lt;typename std::remove_cv
            &lt;typename std::remove_reference&lt;_Tuple&gt;::type&gt;::type&gt;
    { };

  // Combines several std::tuple's into a single one.
  template&lt;typename...&gt;
    struct __combine_tuples;

  template&lt;&gt;
    struct __combine_tuples&lt;&gt;
    {
      typedef tuple&lt;&gt; __type;
    };

  template&lt;typename... _Ts&gt;
    struct __combine_tuples&lt;tuple&lt;_Ts...&gt;&gt;
    {
      typedef tuple&lt;_Ts...&gt; __type;
    };

  template&lt;typename... _T1s, typename... _T2s, typename... _Rem&gt;
    struct __combine_tuples&lt;tuple&lt;_T1s...&gt;, tuple&lt;_T2s...&gt;, _Rem...&gt;
    {
      typedef typename __combine_tuples&lt;tuple&lt;_T1s..., _T2s...&gt;,
					_Rem...&gt;::__type __type;
    };

  // Computes the result type of tuple_cat given a set of tuple-like types.
  template&lt;typename... _Tpls&gt;
    struct __tuple_cat_result
    {
      typedef typename __combine_tuples
        &lt;typename __make_tuple&lt;_Tpls&gt;::__type...&gt;::__type __type;
    };

  // Helper to determine the index set for the first tuple-like
  // type of a given set.
  template&lt;typename...&gt;
    struct __make_1st_indices;

  template&lt;&gt;
    struct __make_1st_indices&lt;&gt;
    {
      typedef std::_Index_tuple&lt;&gt; __type;
    };

  template&lt;typename _Tp, typename... _Tpls&gt;
    struct __make_1st_indices&lt;_Tp, _Tpls...&gt;
    {
      typedef typename std::_Build_index_tuple&lt;std::tuple_size&lt;
	typename std::remove_reference&lt;_Tp&gt;::type&gt;::value&gt;::__type __type;
    };

  // Performs the actual concatenation by step-wise expanding tuple-like
  // objects into the elements,  which are finally forwarded into the
  // result tuple.
  template&lt;typename _Ret, typename _Indices, typename... _Tpls&gt;
    struct __tuple_concater;

  template&lt;typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls&gt;
    struct __tuple_concater&lt;_Ret, std::_Index_tuple&lt;_Is...&gt;, _Tp, _Tpls...&gt;
    {
      template&lt;typename... _Us&gt;
        static constexpr _Ret
        _S_do(_Tp&amp;&amp; __tp, _Tpls&amp;&amp;... __tps, _Us&amp;&amp;... __us)
        {
	  typedef typename __make_1st_indices&lt;_Tpls...&gt;::__type __idx;
	  typedef __tuple_concater&lt;_Ret, __idx, _Tpls...&gt;      __next;
	  return __next::_S_do(std::forward&lt;_Tpls&gt;(__tps)...,
			       std::forward&lt;_Us&gt;(__us)...,
			       std::get&lt;_Is&gt;(std::forward&lt;_Tp&gt;(__tp))...);
	}
    };

  template&lt;typename _Ret&gt;
    struct __tuple_concater&lt;_Ret, std::_Index_tuple&lt;&gt;&gt;
    {
      template&lt;typename... _Us&gt;
	static constexpr _Ret
	_S_do(_Us&amp;&amp;... __us)
        {
	  return _Ret(std::forward&lt;_Us&gt;(__us)...);
	}
    };

  /// tuple_cat
  template&lt;typename... _Tpls, typename = typename
           enable_if&lt;__and_&lt;__is_tuple_like&lt;_Tpls&gt;...&gt;::value&gt;::type&gt;
    constexpr auto
    tuple_cat(_Tpls&amp;&amp;... __tpls)
    -&gt; typename __tuple_cat_result&lt;_Tpls...&gt;::__type
    {
      typedef typename __tuple_cat_result&lt;_Tpls...&gt;::__type __ret;
      typedef typename __make_1st_indices&lt;_Tpls...&gt;::__type __idx;
      typedef __tuple_concater&lt;__ret, __idx, _Tpls...&gt; __concater;
      return __concater::_S_do(std::forward&lt;_Tpls&gt;(__tpls)...);
    }

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 2301. Why is tie not constexpr?
  /// tie
  template&lt;typename... _Elements&gt;
    constexpr tuple&lt;_Elements&amp;...&gt;
    tie(_Elements&amp;... __args) noexcept
    { return tuple&lt;_Elements&amp;...&gt;(__args...); }

  /// swap
  template&lt;typename... _Elements&gt;
    inline
#if __cplusplus &gt; 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
    // Constrained free swap overload, see p0185r1
    typename enable_if&lt;__and_&lt;__is_swappable&lt;_Elements&gt;...&gt;::value
      &gt;::type
#else
    void
#endif
    swap(tuple&lt;_Elements...&gt;&amp; __x, tuple&lt;_Elements...&gt;&amp; __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }

#if __cplusplus &gt; 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
  template&lt;typename... _Elements&gt;
    typename enable_if&lt;!__and_&lt;__is_swappable&lt;_Elements&gt;...&gt;::value&gt;::type
    swap(tuple&lt;_Elements...&gt;&amp;, tuple&lt;_Elements...&gt;&amp;) = delete;
#endif

  // A class (and instance) which can be used in 'tie' when an element
  // of a tuple is not required.
  // _GLIBCXX14_CONSTEXPR
  // 2933. PR for LWG 2773 could be clearer
  struct _Swallow_assign
  {
    template&lt;class _Tp&gt;
      _GLIBCXX14_CONSTEXPR const _Swallow_assign&amp;
      operator=(const _Tp&amp;) const
      { return *this; }
  };

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 2773. Making std::ignore constexpr
  _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{};

  /// Partial specialization for tuples
  template&lt;typename... _Types, typename _Alloc&gt;
    struct uses_allocator&lt;tuple&lt;_Types...&gt;, _Alloc&gt; : true_type { };

  // See stl_pair.h...
  template&lt;class _T1, class _T2&gt;
    template&lt;typename... _Args1, typename... _Args2&gt;
      inline
      pair&lt;_T1, _T2&gt;::
      pair(piecewise_construct_t,
	   tuple&lt;_Args1...&gt; __first, tuple&lt;_Args2...&gt; __second)
      : pair(__first, __second,
	     typename _Build_index_tuple&lt;sizeof...(_Args1)&gt;::__type(),
	     typename _Build_index_tuple&lt;sizeof...(_Args2)&gt;::__type())
      { }

  template&lt;class _T1, class _T2&gt;
    template&lt;typename... _Args1, std::size_t... _Indexes1,
             typename... _Args2, std::size_t... _Indexes2&gt;
      inline
      pair&lt;_T1, _T2&gt;::
      pair(tuple&lt;_Args1...&gt;&amp; __tuple1, tuple&lt;_Args2...&gt;&amp; __tuple2,
	   _Index_tuple&lt;_Indexes1...&gt;, _Index_tuple&lt;_Indexes2...&gt;)
      : first(std::forward&lt;_Args1&gt;(std::get&lt;_Indexes1&gt;(__tuple1))...),
        second(std::forward&lt;_Args2&gt;(std::get&lt;_Indexes2&gt;(__tuple2))...)
      { }

#if __cplusplus &gt; 201402L
# define __cpp_lib_apply 201603

  template &lt;typename _Fn, typename _Tuple, size_t... _Idx&gt;
    constexpr decltype(auto)
    __apply_impl(_Fn&amp;&amp; __f, _Tuple&amp;&amp; __t, index_sequence&lt;_Idx...&gt;)
    {
      return std::__invoke(std::forward&lt;_Fn&gt;(__f),
			   std::get&lt;_Idx&gt;(std::forward&lt;_Tuple&gt;(__t))...);
    }

  template &lt;typename _Fn, typename _Tuple&gt;
    constexpr decltype(auto)
    apply(_Fn&amp;&amp; __f, _Tuple&amp;&amp; __t)
    {
      using _Indices = make_index_sequence&lt;tuple_size_v&lt;decay_t&lt;_Tuple&gt;&gt;&gt;;
      return std::__apply_impl(std::forward&lt;_Fn&gt;(__f),
			       std::forward&lt;_Tuple&gt;(__t),
			       _Indices{});
    }

#define __cpp_lib_make_from_tuple  201606

  template &lt;typename _Tp, typename _Tuple, size_t... _Idx&gt;
    constexpr _Tp
    __make_from_tuple_impl(_Tuple&amp;&amp; __t, index_sequence&lt;_Idx...&gt;)
    { return _Tp(std::get&lt;_Idx&gt;(std::forward&lt;_Tuple&gt;(__t))...); }

  template &lt;typename _Tp, typename _Tuple&gt;
    constexpr _Tp
    make_from_tuple(_Tuple&amp;&amp; __t)
    {
      return __make_from_tuple_impl&lt;_Tp&gt;(
        std::forward&lt;_Tuple&gt;(__t),
	make_index_sequence&lt;tuple_size_v&lt;decay_t&lt;_Tuple&gt;&gt;&gt;{});
    }
#endif // C++17

  /// @}

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++11

#endif // _GLIBCXX_TUPLE
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2F%2Fusr%2Finclude%2Fc%2B%2B%2F8'>⬅ Back to Directory</a>