1    	// <tuple> -*- C++ -*-
2    	
3    	// Copyright (C) 2007-2017 Free Software Foundation, Inc.
4    	//
5    	// This file is part of the GNU ISO C++ Library.  This library is free
6    	// software; you can redistribute it and/or modify it under the
7    	// terms of the GNU General Public License as published by the
8    	// Free Software Foundation; either version 3, or (at your option)
9    	// any later version.
10   	
11   	// This library is distributed in the hope that it will be useful,
12   	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13   	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   	// GNU General Public License for more details.
15   	
16   	// Under Section 7 of GPL version 3, you are granted additional
17   	// permissions described in the GCC Runtime Library Exception, version
18   	// 3.1, as published by the Free Software Foundation.
19   	
20   	// You should have received a copy of the GNU General Public License and
21   	// a copy of the GCC Runtime Library Exception along with this program;
22   	// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23   	// <http://www.gnu.org/licenses/>.
24   	
25   	/** @file include/tuple
26   	 *  This is a Standard C++ Library header.
27   	 */
28   	
29   	#ifndef _GLIBCXX_TUPLE
30   	#define _GLIBCXX_TUPLE 1
31   	
32   	#pragma GCC system_header
33   	
34   	#if __cplusplus < 201103L
35   	# include <bits/c++0x_warning.h>
36   	#else
37   	
38   	#include <utility>
39   	#include <array>
40   	#include <bits/uses_allocator.h>
41   	#include <bits/invoke.h>
42   	
43   	namespace std _GLIBCXX_VISIBILITY(default)
44   	{
45   	_GLIBCXX_BEGIN_NAMESPACE_VERSION
46   	
47   	  /**
48   	   *  @addtogroup utilities
49   	   *  @{
50   	   */
51   	
52   	  template<typename... _Elements>
53   	    class tuple;
54   	
55   	  template<typename _Tp>
56   	    struct __is_empty_non_tuple : is_empty<_Tp> { };
57   	
58   	  // Using EBO for elements that are tuples causes ambiguous base errors.
59   	  template<typename _El0, typename... _El>
60   	    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
61   	
62   	  // Use the Empty Base-class Optimization for empty, non-final types.
63   	  template<typename _Tp>
64   	    using __empty_not_final
65   	    = typename conditional<__is_final(_Tp), false_type,
66   				   __is_empty_non_tuple<_Tp>>::type;
67   	
68   	  template<std::size_t _Idx, typename _Head,
69   		   bool = __empty_not_final<_Head>::value>
70   	    struct _Head_base;
71   	
72   	  template<std::size_t _Idx, typename _Head>
73   	    struct _Head_base<_Idx, _Head, true>
74   	    : public _Head
75   	    {
76   	      constexpr _Head_base()
77   	      : _Head() { }
78   	
79   	      constexpr _Head_base(const _Head& __h)
80   	      : _Head(__h) { }
81   	
82   	      constexpr _Head_base(const _Head_base&) = default;
83   	      constexpr _Head_base(_Head_base&&) = default;
84   	
85   	      template<typename _UHead>
86   	        constexpr _Head_base(_UHead&& __h)
87   		: _Head(std::forward<_UHead>(__h)) { }
88   	
89   	      _Head_base(allocator_arg_t, __uses_alloc0)
90   	      : _Head() { }
91   	
92   	      template<typename _Alloc>
93   		_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
94   		: _Head(allocator_arg, *__a._M_a) { }
95   	
96   	      template<typename _Alloc>
97   		_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
98   		: _Head(*__a._M_a) { }
99   	
100  	      template<typename _UHead>
101  		_Head_base(__uses_alloc0, _UHead&& __uhead)
102  		: _Head(std::forward<_UHead>(__uhead)) { }
103  	
104  	      template<typename _Alloc, typename _UHead>
105  		_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
106  		: _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
107  	
108  	      template<typename _Alloc, typename _UHead>
109  		_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
110  		: _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
111  	
112  	      static constexpr _Head&
113  	      _M_head(_Head_base& __b) noexcept { return __b; }
114  	
115  	      static constexpr const _Head&
116  	      _M_head(const _Head_base& __b) noexcept { return __b; }
117  	    };
118  	
119  	  template<std::size_t _Idx, typename _Head>
120  	    struct _Head_base<_Idx, _Head, false>
121  	    {
122  	      constexpr _Head_base()
123  	      : _M_head_impl() { }
124  	
125  	      constexpr _Head_base(const _Head& __h)
126  	      : _M_head_impl(__h) { }
127  	
128  	      constexpr _Head_base(const _Head_base&) = default;
129  	      constexpr _Head_base(_Head_base&&) = default;
130  	
131  	      template<typename _UHead>
132  	        constexpr _Head_base(_UHead&& __h)
133  		: _M_head_impl(std::forward<_UHead>(__h)) { }
134  	
135  	      _Head_base(allocator_arg_t, __uses_alloc0)
136  	      : _M_head_impl() { }
137  	
138  	      template<typename _Alloc>
139  		_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
140  		: _M_head_impl(allocator_arg, *__a._M_a) { }
141  	
142  	      template<typename _Alloc>
143  		_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
144  		: _M_head_impl(*__a._M_a) { }
145  	
146  	      template<typename _UHead>
147  		_Head_base(__uses_alloc0, _UHead&& __uhead)
148  		: _M_head_impl(std::forward<_UHead>(__uhead)) { }
149  	
150  	      template<typename _Alloc, typename _UHead>
151  		_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
152  		: _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
153  		{ }
154  	
155  	      template<typename _Alloc, typename _UHead>
156  		_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
157  		: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
158  	
159  	      static constexpr _Head&
160  	      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
161  	
162  	      static constexpr const _Head&
163  	      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
164  	
165  	      _Head _M_head_impl;
166  	    };
167  	
168  	  /**
169  	   * Contains the actual implementation of the @c tuple template, stored
170  	   * as a recursive inheritance hierarchy from the first element (most
171  	   * derived class) to the last (least derived class). The @c Idx
172  	   * parameter gives the 0-based index of the element stored at this
173  	   * point in the hierarchy; we use it to implement a constant-time
174  	   * get() operation.
175  	   */
176  	  template<std::size_t _Idx, typename... _Elements>
177  	    struct _Tuple_impl;
178  	
179  	  /**
180  	   * Recursive tuple implementation. Here we store the @c Head element
181  	   * and derive from a @c Tuple_impl containing the remaining elements
182  	   * (which contains the @c Tail).
183  	   */
184  	  template<std::size_t _Idx, typename _Head, typename... _Tail>
185  	    struct _Tuple_impl<_Idx, _Head, _Tail...>
186  	    : public _Tuple_impl<_Idx + 1, _Tail...>,
187  	      private _Head_base<_Idx, _Head>
188  	    {
189  	      template<std::size_t, typename...> friend class _Tuple_impl;
190  	
191  	      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
192  	      typedef _Head_base<_Idx, _Head> _Base;
193  	
194  	      static constexpr _Head&
195  	      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
196  	
197  	      static constexpr const _Head&
198  	      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
199  	
200  	      static constexpr _Inherited&
201  	      _M_tail(_Tuple_impl& __t) noexcept { return __t; }
202  	
203  	      static constexpr const _Inherited&
204  	      _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
205  	
206  	      constexpr _Tuple_impl()
207  	      : _Inherited(), _Base() { }
208  	
209  	      explicit
210  	      constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
211  	      : _Inherited(__tail...), _Base(__head) { }
212  	
213  	      template<typename _UHead, typename... _UTail, typename = typename
214  	               enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
215  	        explicit
216  	        constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
217  		: _Inherited(std::forward<_UTail>(__tail)...),
218  		  _Base(std::forward<_UHead>(__head)) { }
219  	
220  	      constexpr _Tuple_impl(const _Tuple_impl&) = default;
221  	
222  	      constexpr
223  	      _Tuple_impl(_Tuple_impl&& __in)
224  	      noexcept(__and_<is_nothrow_move_constructible<_Head>,
225  		              is_nothrow_move_constructible<_Inherited>>::value)
226  	      : _Inherited(std::move(_M_tail(__in))),
227  		_Base(std::forward<_Head>(_M_head(__in))) { }
228  	
229  	      template<typename... _UElements>
230  	        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
231  		: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
232  		  _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
233  	
234  	      template<typename _UHead, typename... _UTails>
235  	        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
236  		: _Inherited(std::move
237  			     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
238  		  _Base(std::forward<_UHead>
239  			(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
240  	
241  	      template<typename _Alloc>
242  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
243  		: _Inherited(__tag, __a),
244  	          _Base(__tag, __use_alloc<_Head>(__a)) { }
245  	
246  	      template<typename _Alloc>
247  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
248  			    const _Head& __head, const _Tail&... __tail)
249  		: _Inherited(__tag, __a, __tail...),
250  	          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
251  	
252  	      template<typename _Alloc, typename _UHead, typename... _UTail,
253  	               typename = typename enable_if<sizeof...(_Tail)
254  						     == sizeof...(_UTail)>::type>
255  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
256  		            _UHead&& __head, _UTail&&... __tail)
257  		: _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
258  	          _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
259  		        std::forward<_UHead>(__head)) { }
260  	
261  	      template<typename _Alloc>
262  	        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
263  		            const _Tuple_impl& __in)
264  		: _Inherited(__tag, __a, _M_tail(__in)),
265  	          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
266  	
267  	      template<typename _Alloc>
268  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
269  		            _Tuple_impl&& __in)
270  		: _Inherited(__tag, __a, std::move(_M_tail(__in))),
271  		  _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
272  		        std::forward<_Head>(_M_head(__in))) { }
273  	
274  	      template<typename _Alloc, typename... _UElements>
275  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
276  		            const _Tuple_impl<_Idx, _UElements...>& __in)
277  		: _Inherited(__tag, __a,
278  			     _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
279  		  _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
280  			_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
281  	
282  	      template<typename _Alloc, typename _UHead, typename... _UTails>
283  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
284  		            _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
285  		: _Inherited(__tag, __a, std::move
286  			     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
287  		  _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
288  	                std::forward<_UHead>
289  			(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
290  	
291  	      _Tuple_impl&
292  	      operator=(const _Tuple_impl& __in)
293  	      {
294  		_M_head(*this) = _M_head(__in);
295  		_M_tail(*this) = _M_tail(__in);
296  		return *this;
297  	      }
298  	
299  	      _Tuple_impl&
300  	      operator=(_Tuple_impl&& __in)
301  	      noexcept(__and_<is_nothrow_move_assignable<_Head>,
302  		              is_nothrow_move_assignable<_Inherited>>::value)
303  	      {
304  		_M_head(*this) = std::forward<_Head>(_M_head(__in));
305  		_M_tail(*this) = std::move(_M_tail(__in));
306  		return *this;
307  	      }
308  	
309  	      template<typename... _UElements>
310  	        _Tuple_impl&
311  	        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
312  	        {
313  		  _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
314  		  _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
315  		  return *this;
316  		}
317  	
318  	      template<typename _UHead, typename... _UTails>
319  	        _Tuple_impl&
320  	        operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
321  	        {
322  		  _M_head(*this) = std::forward<_UHead>
323  		    (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
324  		  _M_tail(*this) = std::move
325  		    (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
326  		  return *this;
327  		}
328  	
329  	    protected:
330  	      void
331  	      _M_swap(_Tuple_impl& __in)
332  	      noexcept(__is_nothrow_swappable<_Head>::value
333  	               && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
334  	      {
335  		using std::swap;
336  		swap(_M_head(*this), _M_head(__in));
337  		_Inherited::_M_swap(_M_tail(__in));
338  	      }
339  	    };
340  	
341  	  // Basis case of inheritance recursion.
342  	  template<std::size_t _Idx, typename _Head>
343  	    struct _Tuple_impl<_Idx, _Head>
344  	    : private _Head_base<_Idx, _Head>
345  	    {
346  	      template<std::size_t, typename...> friend class _Tuple_impl;
347  	
348  	      typedef _Head_base<_Idx, _Head> _Base;
349  	
350  	      static constexpr _Head&
351  	      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
352  	
353  	      static constexpr const _Head&
354  	      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
355  	
356  	      constexpr _Tuple_impl()
357  	      : _Base() { }
358  	
359  	      explicit
360  	      constexpr _Tuple_impl(const _Head& __head)
361  	      : _Base(__head) { }
362  	
363  	      template<typename _UHead>
364  	        explicit
365  	        constexpr _Tuple_impl(_UHead&& __head)
366  		: _Base(std::forward<_UHead>(__head)) { }
367  	
368  	      constexpr _Tuple_impl(const _Tuple_impl&) = default;
369  	
370  	      constexpr
371  	      _Tuple_impl(_Tuple_impl&& __in)
372  	      noexcept(is_nothrow_move_constructible<_Head>::value)
373  	      : _Base(std::forward<_Head>(_M_head(__in))) { }
374  	
375  	      template<typename _UHead>
376  	        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
377  		: _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
378  	
379  	      template<typename _UHead>
380  	        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
381  		: _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
382  		{ }
383  	
384  	      template<typename _Alloc>
385  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
386  		: _Base(__tag, __use_alloc<_Head>(__a)) { }
387  	
388  	      template<typename _Alloc>
389  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
390  			    const _Head& __head)
391  		: _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
392  	
393  	      template<typename _Alloc, typename _UHead>
394  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
395  		            _UHead&& __head)
396  		: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
397  		        std::forward<_UHead>(__head)) { }
398  	
399  	      template<typename _Alloc>
400  	        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
401  		            const _Tuple_impl& __in)
402  		: _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
403  	
404  	      template<typename _Alloc>
405  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
406  		            _Tuple_impl&& __in)
407  		: _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
408  		        std::forward<_Head>(_M_head(__in))) { }
409  	
410  	      template<typename _Alloc, typename _UHead>
411  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
412  		            const _Tuple_impl<_Idx, _UHead>& __in)
413  		: _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
414  			_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
415  	
416  	      template<typename _Alloc, typename _UHead>
417  		_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
418  		            _Tuple_impl<_Idx, _UHead>&& __in)
419  		: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
420  	                std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
421  		{ }
422  	
423  	      _Tuple_impl&
424  	      operator=(const _Tuple_impl& __in)
425  	      {
426  		_M_head(*this) = _M_head(__in);
427  		return *this;
428  	      }
429  	
430  	      _Tuple_impl&
431  	      operator=(_Tuple_impl&& __in)
432  	      noexcept(is_nothrow_move_assignable<_Head>::value)
433  	      {
434  		_M_head(*this) = std::forward<_Head>(_M_head(__in));
435  		return *this;
436  	      }
437  	
438  	      template<typename _UHead>
439  	        _Tuple_impl&
440  	        operator=(const _Tuple_impl<_Idx, _UHead>& __in)
441  	        {
442  		  _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
443  		  return *this;
444  		}
445  	
446  	      template<typename _UHead>
447  	        _Tuple_impl&
448  	        operator=(_Tuple_impl<_Idx, _UHead>&& __in)
449  	        {
450  		  _M_head(*this)
451  		    = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
452  		  return *this;
453  		}
454  	
455  	    protected:
456  	      void
457  	      _M_swap(_Tuple_impl& __in)
458  	      noexcept(__is_nothrow_swappable<_Head>::value)
459  	      {
460  		using std::swap;
461  		swap(_M_head(*this), _M_head(__in));
462  	      }
463  	    };
464  	
465  	  // Concept utility functions, reused in conditionally-explicit
466  	  // constructors.
467  	  template<bool, typename... _Elements>
468  	  struct _TC
469  	  {
470  	    template<typename... _UElements>
471  	    static constexpr bool _ConstructibleTuple()
472  	    {
473  	      return __and_<is_constructible<_Elements, const _UElements&>...>::value;
474  	    }
475  	
476  	    template<typename... _UElements>
477  	    static constexpr bool _ImplicitlyConvertibleTuple()
478  	    {
479  	      return __and_<is_convertible<const _UElements&, _Elements>...>::value;
480  	    }
481  	
482  	    template<typename... _UElements>
483  	    static constexpr bool _MoveConstructibleTuple()
484  	    {
485  	      return __and_<is_constructible<_Elements, _UElements&&>...>::value;
486  	    }
487  	
488  	    template<typename... _UElements>
489  	    static constexpr bool _ImplicitlyMoveConvertibleTuple()
490  	    {
491  	      return __and_<is_convertible<_UElements&&, _Elements>...>::value;
492  	    }
493  	
494  	    template<typename _SrcTuple>
495  	    static constexpr bool _NonNestedTuple()
496  	    {
497  	      return  __and_<__not_<is_same<tuple<_Elements...>,
498  	                                   typename remove_cv<
499  	                                     typename remove_reference<_SrcTuple>::type
500  	                                   >::type>>,
501  	                     __not_<is_convertible<_SrcTuple, _Elements...>>,
502  	                     __not_<is_constructible<_Elements..., _SrcTuple>>
503  	              >::value;
504  	    }
505  	    template<typename... _UElements>
506  	    static constexpr bool _NotSameTuple()
507  	    {
508  	      return  __not_<is_same<tuple<_Elements...>,
509  				     typename remove_const<
510  				       typename remove_reference<_UElements...>::type
511  				       >::type>>::value;
512  	    }
513  	  };
514  	
515  	  template<typename... _Elements>
516  	  struct _TC<false, _Elements...>
517  	  {
518  	    template<typename... _UElements>
519  	    static constexpr bool _ConstructibleTuple()
520  	    {
521  	      return false;
522  	    }
523  	
524  	    template<typename... _UElements>
525  	    static constexpr bool _ImplicitlyConvertibleTuple()
526  	    {
527  	      return false;
528  	    }
529  	
530  	    template<typename... _UElements>
531  	    static constexpr bool _MoveConstructibleTuple()
532  	    {
533  	      return false;
534  	    }
535  	
536  	    template<typename... _UElements>
537  	    static constexpr bool _ImplicitlyMoveConvertibleTuple()
538  	    {
539  	      return false;
540  	    }
541  	
542  	    template<typename... _UElements>
543  	    static constexpr bool _NonNestedTuple()
544  	    {
545  	      return true;
546  	    }
547  	    template<typename... _UElements>
548  	    static constexpr bool _NotSameTuple()
549  	    {
550  	      return  true;
551  	    }
552  	  };
553  	
554  	  /// Primary class template, tuple
555  	  template<typename... _Elements>
556  	    class tuple : public _Tuple_impl<0, _Elements...>
557  	    {
558  	      typedef _Tuple_impl<0, _Elements...> _Inherited;
559  	
560  	      // Used for constraining the default constructor so
561  	      // that it becomes dependent on the constraints.
562  	      template<typename _Dummy>
563  	      struct _TC2
564  	      {
565  	        static constexpr bool _DefaultConstructibleTuple()
566  	        {
567  	          return __and_<is_default_constructible<_Elements>...>::value;
568  	        }
569  	        static constexpr bool _ImplicitlyDefaultConstructibleTuple()
570  	        {
571  	          return __and_<__is_implicitly_default_constructible<_Elements>...>
572  	            ::value;
573  	        }
574  	      };
575  	
576  	    public:
577  	      template<typename _Dummy = void,
578  	               typename enable_if<_TC2<_Dummy>::
579  	                                    _ImplicitlyDefaultConstructibleTuple(),
580  	                                  bool>::type = true>
581  	      constexpr tuple()
582  	      : _Inherited() { }
583  	
584  	      template<typename _Dummy = void,
585  	               typename enable_if<_TC2<_Dummy>::
586  	                                    _DefaultConstructibleTuple()
587  	                                  &&
588  	                                  !_TC2<_Dummy>::
589  	                                    _ImplicitlyDefaultConstructibleTuple(),
590  	                                  bool>::type = false>
591  	      explicit constexpr tuple()
592  	      : _Inherited() { }
593  	
594  	      // Shortcut for the cases where constructors taking _Elements...
595  	      // need to be constrained.
596  	      template<typename _Dummy> using _TCC =
597  	        _TC<is_same<_Dummy, void>::value,
598  	            _Elements...>;
599  	
600  	      template<typename _Dummy = void,
601  	               typename enable_if<
602  	                 _TCC<_Dummy>::template
603  	                   _ConstructibleTuple<_Elements...>()
604  	                 && _TCC<_Dummy>::template
605  	                   _ImplicitlyConvertibleTuple<_Elements...>()
606  	                 && (sizeof...(_Elements) >= 1),
607  	               bool>::type=true>
608  	        constexpr tuple(const _Elements&... __elements)
609  	      : _Inherited(__elements...) { }
610  	
611  	      template<typename _Dummy = void,
612  	               typename enable_if<
613  	                 _TCC<_Dummy>::template
614  	                   _ConstructibleTuple<_Elements...>()
615  	                 && !_TCC<_Dummy>::template
616  	                   _ImplicitlyConvertibleTuple<_Elements...>()
617  	                 && (sizeof...(_Elements) >= 1),
618  	               bool>::type=false>
619  	      explicit constexpr tuple(const _Elements&... __elements)
620  	      : _Inherited(__elements...) { }
621  	
622  	      // Shortcut for the cases where constructors taking _UElements...
623  	      // need to be constrained.
624  	      template<typename... _UElements> using _TMC =
625  	                  _TC<(sizeof...(_Elements) == sizeof...(_UElements))
626  			      && (_TC<(sizeof...(_UElements)==1), _Elements...>::
627  				  template _NotSameTuple<_UElements...>()),
628  	                      _Elements...>;
629  	
630  	      // Shortcut for the cases where constructors taking tuple<_UElements...>
631  	      // need to be constrained.
632  	      template<typename... _UElements> using _TMCT =
633  	                  _TC<(sizeof...(_Elements) == sizeof...(_UElements))
634  			      && !is_same<tuple<_Elements...>,
635  					  tuple<_UElements...>>::value,
636  	                      _Elements...>;
637  	
638  	      template<typename... _UElements, typename
639  		       enable_if<
640  			  _TMC<_UElements...>::template
641  	                    _MoveConstructibleTuple<_UElements...>()
642  	                  && _TMC<_UElements...>::template
643  	                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
644  	                  && (sizeof...(_Elements) >= 1),
645  	        bool>::type=true>
646  	        constexpr tuple(_UElements&&... __elements)
647  	        : _Inherited(std::forward<_UElements>(__elements)...) { }
648  	
649  	      template<typename... _UElements, typename
650  	        enable_if<
651  			  _TMC<_UElements...>::template
652  	                    _MoveConstructibleTuple<_UElements...>()
653  	                  && !_TMC<_UElements...>::template
654  	                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
655  	                  && (sizeof...(_Elements) >= 1),
656  	        bool>::type=false>
657  	        explicit constexpr tuple(_UElements&&... __elements)
658  		: _Inherited(std::forward<_UElements>(__elements)...) {	}
659  	
660  	      constexpr tuple(const tuple&) = default;
661  	
662  	      constexpr tuple(tuple&&) = default;
663  	
664  	      // Shortcut for the cases where constructors taking tuples
665  	      // must avoid creating temporaries.
666  	      template<typename _Dummy> using _TNTC =
667  	        _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
668  	            _Elements...>;
669  	
670  	      template<typename... _UElements, typename _Dummy = void, typename
671  	        enable_if<_TMCT<_UElements...>::template
672  	                    _ConstructibleTuple<_UElements...>()
673  	                  && _TMCT<_UElements...>::template
674  	                    _ImplicitlyConvertibleTuple<_UElements...>()
675  	                  && _TNTC<_Dummy>::template
676  	                    _NonNestedTuple<const tuple<_UElements...>&>(),
677  	        bool>::type=true>
678  	        constexpr tuple(const tuple<_UElements...>& __in)
679  	        : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
680  	        { }
681  	
682  	      template<typename... _UElements, typename _Dummy = void, typename
683  	        enable_if<_TMCT<_UElements...>::template
684  	                    _ConstructibleTuple<_UElements...>()
685  	                  && !_TMCT<_UElements...>::template
686  	                    _ImplicitlyConvertibleTuple<_UElements...>()
687  	                  && _TNTC<_Dummy>::template
688  	                    _NonNestedTuple<const tuple<_UElements...>&>(),
689  	        bool>::type=false>
690  	        explicit constexpr tuple(const tuple<_UElements...>& __in)
691  	        : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
692  	        { }
693  	
694  	      template<typename... _UElements, typename _Dummy = void, typename
695  	        enable_if<_TMCT<_UElements...>::template
696  	                    _MoveConstructibleTuple<_UElements...>()
697  	                  && _TMCT<_UElements...>::template
698  	                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
699  	                  && _TNTC<_Dummy>::template
700  	                    _NonNestedTuple<tuple<_UElements...>&&>(),
701  	        bool>::type=true>
702  	        constexpr tuple(tuple<_UElements...>&& __in)
703  	        : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
704  	
705  	      template<typename... _UElements, typename _Dummy = void, typename
706  	        enable_if<_TMCT<_UElements...>::template
707  	                    _MoveConstructibleTuple<_UElements...>()
708  	                  && !_TMCT<_UElements...>::template
709  	                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
710  	                  && _TNTC<_Dummy>::template
711  	                    _NonNestedTuple<tuple<_UElements...>&&>(),
712  	        bool>::type=false>
713  	        explicit constexpr tuple(tuple<_UElements...>&& __in)
714  	        : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
715  	
716  	      // Allocator-extended constructors.
717  	
718  	      template<typename _Alloc>
719  		tuple(allocator_arg_t __tag, const _Alloc& __a)
720  		: _Inherited(__tag, __a) { }
721  	
722  	      template<typename _Alloc, typename _Dummy = void,
723  	               typename enable_if<
724  	                 _TCC<_Dummy>::template
725  	                   _ConstructibleTuple<_Elements...>()
726  	                 && _TCC<_Dummy>::template
727  	                   _ImplicitlyConvertibleTuple<_Elements...>(),
728  	               bool>::type=true>
729  		tuple(allocator_arg_t __tag, const _Alloc& __a,
730  		      const _Elements&... __elements)
731  		: _Inherited(__tag, __a, __elements...) { }
732  	
733  	      template<typename _Alloc, typename _Dummy = void,
734  	               typename enable_if<
735  	                 _TCC<_Dummy>::template
736  	                   _ConstructibleTuple<_Elements...>()
737  	                 && !_TCC<_Dummy>::template
738  	                   _ImplicitlyConvertibleTuple<_Elements...>(),
739  	               bool>::type=false>
740  		explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
741  	                       const _Elements&... __elements)
742  		: _Inherited(__tag, __a, __elements...) { }
743  	
744  	      template<typename _Alloc, typename... _UElements, typename
745  	        enable_if<_TMC<_UElements...>::template
746  	                    _MoveConstructibleTuple<_UElements...>()
747  	                  && _TMC<_UElements...>::template
748  	                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
749  	        bool>::type=true>
750  		tuple(allocator_arg_t __tag, const _Alloc& __a,
751  		      _UElements&&... __elements)
752  		: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
753  	       	{ }
754  	
755  	      template<typename _Alloc, typename... _UElements, typename
756  	        enable_if<_TMC<_UElements...>::template
757  	                    _MoveConstructibleTuple<_UElements...>()
758  	                  && !_TMC<_UElements...>::template
759  	                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
760  	        bool>::type=false>
761  		explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
762  		      _UElements&&... __elements)
763  		: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
764  	        { }
765  	
766  	      template<typename _Alloc>
767  		tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
768  		: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
769  	
770  	      template<typename _Alloc>
771  		tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
772  		: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
773  	
774  	      template<typename _Alloc, typename _Dummy = void,
775  		       typename... _UElements, typename
776  	        enable_if<_TMCT<_UElements...>::template
777  	                    _ConstructibleTuple<_UElements...>()
778  	                  && _TMCT<_UElements...>::template
779  	                    _ImplicitlyConvertibleTuple<_UElements...>()
780  	                  && _TNTC<_Dummy>::template
781  	                    _NonNestedTuple<tuple<_UElements...>&&>(),
782  	        bool>::type=true>
783  		tuple(allocator_arg_t __tag, const _Alloc& __a,
784  		      const tuple<_UElements...>& __in)
785  		: _Inherited(__tag, __a,
786  		             static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
787  		{ }
788  	
789  	      template<typename _Alloc, typename _Dummy = void,
790  		       typename... _UElements, typename
791  	        enable_if<_TMCT<_UElements...>::template
792  	                    _ConstructibleTuple<_UElements...>()
793  	                  && !_TMCT<_UElements...>::template
794  	                    _ImplicitlyConvertibleTuple<_UElements...>()
795  	                  && _TNTC<_Dummy>::template
796  	                    _NonNestedTuple<tuple<_UElements...>&&>(),
797  	        bool>::type=false>
798  		explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
799  		      const tuple<_UElements...>& __in)
800  		: _Inherited(__tag, __a,
801  		             static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
802  		{ }
803  	
804  	      template<typename _Alloc, typename _Dummy = void,
805  		       typename... _UElements, typename
806  	        enable_if<_TMCT<_UElements...>::template
807  	                    _MoveConstructibleTuple<_UElements...>()
808  	                  && _TMCT<_UElements...>::template
809  	                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
810  	                  && _TNTC<_Dummy>::template
811  	                    _NonNestedTuple<tuple<_UElements...>&&>(),
812  	        bool>::type=true>
813  		tuple(allocator_arg_t __tag, const _Alloc& __a,
814  		      tuple<_UElements...>&& __in)
815  		: _Inherited(__tag, __a,
816  		             static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
817  		{ }
818  	
819  	      template<typename _Alloc, typename _Dummy = void,
820  		       typename... _UElements, typename
821  	        enable_if<_TMCT<_UElements...>::template
822  	                    _MoveConstructibleTuple<_UElements...>()
823  	                  && !_TMCT<_UElements...>::template
824  	                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
825  	                  && _TNTC<_Dummy>::template
826  	                    _NonNestedTuple<tuple<_UElements...>&&>(),
827  	        bool>::type=false>
828  		explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
829  		      tuple<_UElements...>&& __in)
830  		: _Inherited(__tag, __a,
831  		             static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
832  		{ }
833  	
834  	      tuple&
835  	      operator=(const tuple& __in)
836  	      {
837  		static_cast<_Inherited&>(*this) = __in;
838  		return *this;
839  	      }
840  	
841  	      tuple&
842  	      operator=(tuple&& __in)
843  	      noexcept(is_nothrow_move_assignable<_Inherited>::value)
844  	      {
845  		static_cast<_Inherited&>(*this) = std::move(__in);
846  		return *this;
847  	      }
848  	
849  	      template<typename... _UElements>
850  		typename
851  		       enable_if<sizeof...(_UElements)
852  				 == sizeof...(_Elements), tuple&>::type
853  	        operator=(const tuple<_UElements...>& __in)
854  	        {
855  		  static_cast<_Inherited&>(*this) = __in;
856  		  return *this;
857  		}
858  	
859  	      template<typename... _UElements>
860  		typename
861  		       enable_if<sizeof...(_UElements)
862  				 == sizeof...(_Elements), tuple&>::type
863  	        operator=(tuple<_UElements...>&& __in)
864  	        {
865  		  static_cast<_Inherited&>(*this) = std::move(__in);
866  		  return *this;
867  		}
868  	
869  	      void
870  	      swap(tuple& __in)
871  	      noexcept(noexcept(__in._M_swap(__in)))
872  	      { _Inherited::_M_swap(__in); }
873  	    };
874  	
875  	#if __cpp_deduction_guides >= 201606
876  	  template<typename... _UTypes>
877  	    tuple(_UTypes...) -> tuple<_UTypes...>;
878  	  template<typename _T1, typename _T2>
879  	    tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
880  	  template<typename _Alloc, typename... _UTypes>
881  	    tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
882  	  template<typename _Alloc, typename _T1, typename _T2>
883  	    tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
884  	  template<typename _Alloc, typename... _UTypes>
885  	    tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;
886  	#endif
887  	
888  	  // Explicit specialization, zero-element tuple.
889  	  template<>
890  	    class tuple<>
891  	    {
892  	    public:
893  	      void swap(tuple&) noexcept { /* no-op */ }
894  	      // We need the default since we're going to define no-op
895  	      // allocator constructors.
896  	      tuple() = default;
897  	      // No-op allocator constructors.
898  	      template<typename _Alloc>
899  		tuple(allocator_arg_t, const _Alloc&) { }
900  	      template<typename _Alloc>
901  		tuple(allocator_arg_t, const _Alloc&, const tuple&) { }
902  	    };
903  	
904  	  /// Partial specialization, 2-element tuple.
905  	  /// Includes construction and assignment from a pair.
906  	  template<typename _T1, typename _T2>
907  	    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
908  	    {
909  	      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
910  	
911  	    public:
912  	      template <typename _U1 = _T1,
913  	                typename _U2 = _T2,
914  	                typename enable_if<__and_<
915  	                                     __is_implicitly_default_constructible<_U1>,
916  	                                     __is_implicitly_default_constructible<_U2>>
917  	                                   ::value, bool>::type = true>
918  	
919  	      constexpr tuple()
920  	      : _Inherited() { }
921  	
922  	      template <typename _U1 = _T1,
923  	                typename _U2 = _T2,
924  	                typename enable_if<
925  	                  __and_<
926  	                    is_default_constructible<_U1>,
927  	                    is_default_constructible<_U2>,
928  	                    __not_<
929  	                      __and_<__is_implicitly_default_constructible<_U1>,
930  	                             __is_implicitly_default_constructible<_U2>>>>
931  	                  ::value, bool>::type = false>
932  	
933  	      explicit constexpr tuple()
934  	      : _Inherited() { }
935  	
936  	      // Shortcut for the cases where constructors taking _T1, _T2
937  	      // need to be constrained.
938  	      template<typename _Dummy> using _TCC =
939  	        _TC<is_same<_Dummy, void>::value, _T1, _T2>;
940  	
941  	      template<typename _Dummy = void, typename
942  	               enable_if<_TCC<_Dummy>::template
943  	                           _ConstructibleTuple<_T1, _T2>()
944  	                         && _TCC<_Dummy>::template
945  	                           _ImplicitlyConvertibleTuple<_T1, _T2>(),
946  		bool>::type = true>
947  	        constexpr tuple(const _T1& __a1, const _T2& __a2)
948  	        : _Inherited(__a1, __a2) { }
949  	
950  	      template<typename _Dummy = void, typename
951  	               enable_if<_TCC<_Dummy>::template
952  	                           _ConstructibleTuple<_T1, _T2>()
953  	                         && !_TCC<_Dummy>::template
954  	                           _ImplicitlyConvertibleTuple<_T1, _T2>(),
955  		bool>::type = false>
956  	        explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
957  	        : _Inherited(__a1, __a2) { }
958  	
959  	      // Shortcut for the cases where constructors taking _U1, _U2
960  	      // need to be constrained.
961  	      using _TMC = _TC<true, _T1, _T2>;
962  	
963  	      template<typename _U1, typename _U2, typename
964  	        enable_if<_TMC::template
965  	                    _MoveConstructibleTuple<_U1, _U2>()
966  	                  && _TMC::template
967  	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
968  		          && !is_same<typename decay<_U1>::type,
969  				      allocator_arg_t>::value,
970  		bool>::type = true>
971  	        constexpr tuple(_U1&& __a1, _U2&& __a2)
972  		: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
973  	
974  	      template<typename _U1, typename _U2, typename
975  	        enable_if<_TMC::template
976  	                    _MoveConstructibleTuple<_U1, _U2>()
977  	                  && !_TMC::template
978  	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
979  		          && !is_same<typename decay<_U1>::type,
980  				      allocator_arg_t>::value,
981  		bool>::type = false>
982  	        explicit constexpr tuple(_U1&& __a1, _U2&& __a2)
983  		: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
984  	
985  	      constexpr tuple(const tuple&) = default;
986  	
987  	      constexpr tuple(tuple&&) = default;
988  	
989  	      template<typename _U1, typename _U2, typename
990  	        enable_if<_TMC::template
991  	                    _ConstructibleTuple<_U1, _U2>()
992  	                  && _TMC::template
993  	                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
994  		bool>::type = true>
995  	        constexpr tuple(const tuple<_U1, _U2>& __in)
996  		: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
997  	
998  	      template<typename _U1, typename _U2, typename
999  	        enable_if<_TMC::template
1000 	                    _ConstructibleTuple<_U1, _U2>()
1001 	                  && !_TMC::template
1002 	                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
1003 		bool>::type = false>
1004 	        explicit constexpr tuple(const tuple<_U1, _U2>& __in)
1005 		: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
1006 	
1007 	      template<typename _U1, typename _U2, typename
1008 	        enable_if<_TMC::template
1009 	                    _MoveConstructibleTuple<_U1, _U2>()
1010 	                  && _TMC::template
1011 	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1012 		bool>::type = true>
1013 	        constexpr tuple(tuple<_U1, _U2>&& __in)
1014 		: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
1015 	
1016 	      template<typename _U1, typename _U2, typename
1017 	        enable_if<_TMC::template
1018 	                    _MoveConstructibleTuple<_U1, _U2>()
1019 	                  && !_TMC::template
1020 	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1021 		bool>::type = false>
1022 	        explicit constexpr tuple(tuple<_U1, _U2>&& __in)
1023 		: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
1024 	
1025 	      template<typename _U1, typename _U2, typename
1026 	        enable_if<_TMC::template
1027 	                    _ConstructibleTuple<_U1, _U2>()
1028 	                  && _TMC::template
1029 	                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
1030 		bool>::type = true>
1031 	        constexpr tuple(const pair<_U1, _U2>& __in)
1032 		: _Inherited(__in.first, __in.second) { }
1033 	
1034 	      template<typename _U1, typename _U2, typename
1035 	        enable_if<_TMC::template
1036 	                    _ConstructibleTuple<_U1, _U2>()
1037 	                  && !_TMC::template
1038 	                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
1039 		bool>::type = false>
1040 	        explicit constexpr tuple(const pair<_U1, _U2>& __in)
1041 		: _Inherited(__in.first, __in.second) { }
1042 	
1043 	      template<typename _U1, typename _U2, typename
1044 	        enable_if<_TMC::template
1045 	                    _MoveConstructibleTuple<_U1, _U2>()
1046 	                  && _TMC::template
1047 	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1048 		bool>::type = true>
1049 	        constexpr tuple(pair<_U1, _U2>&& __in)
1050 		: _Inherited(std::forward<_U1>(__in.first),
1051 			     std::forward<_U2>(__in.second)) { }
1052 	
1053 	      template<typename _U1, typename _U2, typename
1054 	        enable_if<_TMC::template
1055 	                    _MoveConstructibleTuple<_U1, _U2>()
1056 	                  && !_TMC::template
1057 	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1058 		bool>::type = false>
1059 	        explicit constexpr tuple(pair<_U1, _U2>&& __in)
1060 		: _Inherited(std::forward<_U1>(__in.first),
1061 			     std::forward<_U2>(__in.second)) { }
1062 	
1063 	      // Allocator-extended constructors.
1064 	
1065 	      template<typename _Alloc>
1066 		tuple(allocator_arg_t __tag, const _Alloc& __a)
1067 		: _Inherited(__tag, __a) { }
1068 	
1069 	      template<typename _Alloc, typename _Dummy = void,
1070 	               typename enable_if<
1071 	                 _TCC<_Dummy>::template
1072 	                   _ConstructibleTuple<_T1, _T2>()
1073 	                 && _TCC<_Dummy>::template
1074 	                   _ImplicitlyConvertibleTuple<_T1, _T2>(),
1075 	               bool>::type=true>
1076 	
1077 		tuple(allocator_arg_t __tag, const _Alloc& __a,
1078 		      const _T1& __a1, const _T2& __a2)
1079 		: _Inherited(__tag, __a, __a1, __a2) { }
1080 	
1081 	      template<typename _Alloc, typename _Dummy = void,
1082 	               typename enable_if<
1083 	                 _TCC<_Dummy>::template
1084 	                   _ConstructibleTuple<_T1, _T2>()
1085 	                 && !_TCC<_Dummy>::template
1086 	                   _ImplicitlyConvertibleTuple<_T1, _T2>(),
1087 	               bool>::type=false>
1088 	
1089 		explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1090 		      const _T1& __a1, const _T2& __a2)
1091 		: _Inherited(__tag, __a, __a1, __a2) { }
1092 	
1093 	      template<typename _Alloc, typename _U1, typename _U2, typename
1094 	        enable_if<_TMC::template
1095 	                    _MoveConstructibleTuple<_U1, _U2>()
1096 	                  && _TMC::template
1097 	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1098 		bool>::type = true>
1099 		tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
1100 		: _Inherited(__tag, __a, std::forward<_U1>(__a1),
1101 		             std::forward<_U2>(__a2)) { }
1102 	
1103 	      template<typename _Alloc, typename _U1, typename _U2, typename
1104 	        enable_if<_TMC::template
1105 	                    _MoveConstructibleTuple<_U1, _U2>()
1106 	                  && !_TMC::template
1107 	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1108 		bool>::type = false>
1109 		explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1110 	                       _U1&& __a1, _U2&& __a2)
1111 		: _Inherited(__tag, __a, std::forward<_U1>(__a1),
1112 		             std::forward<_U2>(__a2)) { }
1113 	
1114 	      template<typename _Alloc>
1115 		tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
1116 		: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
1117 	
1118 	      template<typename _Alloc>
1119 		tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
1120 		: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
1121 	
1122 	      template<typename _Alloc, typename _U1, typename _U2, typename
1123 	        enable_if<_TMC::template
1124 	                    _ConstructibleTuple<_U1, _U2>()
1125 	                  && _TMC::template
1126 	                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
1127 		bool>::type = true>
1128 		tuple(allocator_arg_t __tag, const _Alloc& __a,
1129 		      const tuple<_U1, _U2>& __in)
1130 		: _Inherited(__tag, __a,
1131 		             static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
1132 		{ }
1133 	
1134 	      template<typename _Alloc, typename _U1, typename _U2, typename
1135 	        enable_if<_TMC::template
1136 	                    _ConstructibleTuple<_U1, _U2>()
1137 	                  && !_TMC::template
1138 	                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
1139 		bool>::type = false>
1140 		explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1141 		      const tuple<_U1, _U2>& __in)
1142 		: _Inherited(__tag, __a,
1143 		             static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
1144 		{ }
1145 	
1146 	      template<typename _Alloc, typename _U1, typename _U2, typename
1147 	        enable_if<_TMC::template
1148 	                    _MoveConstructibleTuple<_U1, _U2>()
1149 	                  && _TMC::template
1150 	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1151 		bool>::type = true>
1152 		tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
1153 		: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
1154 		{ }
1155 	
1156 	      template<typename _Alloc, typename _U1, typename _U2, typename
1157 	        enable_if<_TMC::template
1158 	                    _MoveConstructibleTuple<_U1, _U2>()
1159 	                  && !_TMC::template
1160 	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1161 		bool>::type = false>
1162 		explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1163 	                       tuple<_U1, _U2>&& __in)
1164 		: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
1165 		{ }
1166 	
1167 	      template<typename _Alloc, typename _U1, typename _U2, typename
1168 	        enable_if<_TMC::template
1169 	                    _ConstructibleTuple<_U1, _U2>()
1170 	                  && _TMC::template
1171 	                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
1172 		bool>::type = true>
1173 	        tuple(allocator_arg_t __tag, const _Alloc& __a,
1174 		      const pair<_U1, _U2>& __in)
1175 		: _Inherited(__tag, __a, __in.first, __in.second) { }
1176 	
1177 	      template<typename _Alloc, typename _U1, typename _U2, typename
1178 	        enable_if<_TMC::template
1179 	                    _ConstructibleTuple<_U1, _U2>()
1180 	                  && !_TMC::template
1181 	                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
1182 		bool>::type = false>
1183 	        explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1184 		      const pair<_U1, _U2>& __in)
1185 		: _Inherited(__tag, __a, __in.first, __in.second) { }
1186 	
1187 	      template<typename _Alloc, typename _U1, typename _U2, typename
1188 	        enable_if<_TMC::template
1189 	                    _MoveConstructibleTuple<_U1, _U2>()
1190 	                  && _TMC::template
1191 	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1192 		bool>::type = true>
1193 	        tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
1194 		: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
1195 			     std::forward<_U2>(__in.second)) { }
1196 	
1197 	      template<typename _Alloc, typename _U1, typename _U2, typename
1198 	        enable_if<_TMC::template
1199 	                    _MoveConstructibleTuple<_U1, _U2>()
1200 	                  && !_TMC::template
1201 	                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
1202 		bool>::type = false>
1203 	        explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
1204 	                       pair<_U1, _U2>&& __in)
1205 		: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
1206 			     std::forward<_U2>(__in.second)) { }
1207 	
1208 	      tuple&
1209 	      operator=(const tuple& __in)
1210 	      {
1211 		static_cast<_Inherited&>(*this) = __in;
1212 		return *this;
1213 	      }
1214 	
1215 	      tuple&
1216 	      operator=(tuple&& __in)
1217 	      noexcept(is_nothrow_move_assignable<_Inherited>::value)
1218 	      {
1219 		static_cast<_Inherited&>(*this) = std::move(__in);
1220 		return *this;
1221 	      }
1222 	
1223 	      template<typename _U1, typename _U2>
1224 	        tuple&
1225 	        operator=(const tuple<_U1, _U2>& __in)
1226 	        {
1227 		  static_cast<_Inherited&>(*this) = __in;
1228 		  return *this;
1229 		}
1230 	
1231 	      template<typename _U1, typename _U2>
1232 	        tuple&
1233 	        operator=(tuple<_U1, _U2>&& __in)
1234 	        {
1235 		  static_cast<_Inherited&>(*this) = std::move(__in);
1236 		  return *this;
1237 		}
1238 	
1239 	      template<typename _U1, typename _U2>
1240 	        tuple&
1241 	        operator=(const pair<_U1, _U2>& __in)
1242 	        {
1243 		  this->_M_head(*this) = __in.first;
1244 		  this->_M_tail(*this)._M_head(*this) = __in.second;
1245 		  return *this;
1246 		}
1247 	
1248 	      template<typename _U1, typename _U2>
1249 	        tuple&
1250 	        operator=(pair<_U1, _U2>&& __in)
1251 	        {
1252 		  this->_M_head(*this) = std::forward<_U1>(__in.first);
1253 		  this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
1254 		  return *this;
1255 		}
1256 	
1257 	      void
1258 	      swap(tuple& __in)
1259 	      noexcept(noexcept(__in._M_swap(__in)))
1260 	      { _Inherited::_M_swap(__in); }
1261 	    };
1262 	
1263 	
1264 	  /// class tuple_size
1265 	  template<typename... _Elements>
1266 	    struct tuple_size<tuple<_Elements...>>
1267 	    : public integral_constant<std::size_t, sizeof...(_Elements)> { };
1268 	
1269 	#if __cplusplus > 201402L
1270 	  template <typename _Tp>
1271 	    inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
1272 	#endif
1273 	
1274 	  /**
1275 	   * Recursive case for tuple_element: strip off the first element in
1276 	   * the tuple and retrieve the (i-1)th element of the remaining tuple.
1277 	   */
1278 	  template<std::size_t __i, typename _Head, typename... _Tail>
1279 	    struct tuple_element<__i, tuple<_Head, _Tail...> >
1280 	    : tuple_element<__i - 1, tuple<_Tail...> > { };
1281 	
1282 	  /**
1283 	   * Basis case for tuple_element: The first element is the one we're seeking.
1284 	   */
1285 	  template<typename _Head, typename... _Tail>
1286 	    struct tuple_element<0, tuple<_Head, _Tail...> >
1287 	    {
1288 	      typedef _Head type;
1289 	    };
1290 	
1291 	  /**
1292 	   * Error case for tuple_element: invalid index.
1293 	   */
1294 	  template<size_t __i>
1295 	    struct tuple_element<__i, tuple<>>
1296 	    {
1297 	      static_assert(__i < tuple_size<tuple<>>::value,
1298 		  "tuple index is in range");
1299 	    };
1300 	
1301 	  template<std::size_t __i, typename _Head, typename... _Tail>
1302 	    constexpr _Head&
1303 	    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1304 	    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1305 	
1306 	  template<std::size_t __i, typename _Head, typename... _Tail>
1307 	    constexpr const _Head&
1308 	    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1309 	    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1310 	
1311 	  /// Return a reference to the ith element of a tuple.
1312 	  template<std::size_t __i, typename... _Elements>
1313 	    constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1314 	    get(tuple<_Elements...>& __t) noexcept
1315 	    { return std::__get_helper<__i>(__t); }
1316 	
1317 	  /// Return a const reference to the ith element of a const tuple.
1318 	  template<std::size_t __i, typename... _Elements>
1319 	    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1320 	    get(const tuple<_Elements...>& __t) noexcept
1321 	    { return std::__get_helper<__i>(__t); }
1322 	
1323 	  /// Return an rvalue reference to the ith element of a tuple rvalue.
1324 	  template<std::size_t __i, typename... _Elements>
1325 	    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1326 	    get(tuple<_Elements...>&& __t) noexcept
1327 	    {
1328 	      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
1329 	      return std::forward<__element_type&&>(std::get<__i>(__t));
1330 	    }
1331 	
1332 	#if __cplusplus > 201103L
1333 	
1334 	#define __cpp_lib_tuples_by_type 201304
1335 	
1336 	  template<typename _Head, size_t __i, typename... _Tail>
1337 	    constexpr _Head&
1338 	    __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1339 	    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1340 	
1341 	  template<typename _Head, size_t __i, typename... _Tail>
1342 	    constexpr const _Head&
1343 	    __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1344 	    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1345 	
1346 	  /// Return a reference to the unique element of type _Tp of a tuple.
1347 	  template <typename _Tp, typename... _Types>
1348 	    constexpr _Tp&
1349 	    get(tuple<_Types...>& __t) noexcept
1350 	    { return std::__get_helper2<_Tp>(__t); }
1351 	
1352 	  /// Return a reference to the unique element of type _Tp of a tuple rvalue.
1353 	  template <typename _Tp, typename... _Types>
1354 	    constexpr _Tp&&
1355 	    get(tuple<_Types...>&& __t) noexcept
1356 	    { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
1357 	
1358 	  /// Return a const reference to the unique element of type _Tp of a tuple.
1359 	  template <typename _Tp, typename... _Types>
1360 	    constexpr const _Tp&
1361 	    get(const tuple<_Types...>& __t) noexcept
1362 	    { return std::__get_helper2<_Tp>(__t); }
1363 	#endif
1364 	
1365 	  // This class performs the comparison operations on tuples
1366 	  template<typename _Tp, typename _Up, size_t __i, size_t __size>
1367 	    struct __tuple_compare
1368 	    {
1369 	      static constexpr bool
1370 	      __eq(const _Tp& __t, const _Up& __u)
1371 	      {
1372 		return bool(std::get<__i>(__t) == std::get<__i>(__u))
1373 		  && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
1374 	      }
1375 	
1376 	      static constexpr bool
1377 	      __less(const _Tp& __t, const _Up& __u)
1378 	      {
1379 		return bool(std::get<__i>(__t) < std::get<__i>(__u))
1380 		  || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
1381 		      && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
1382 	      }
1383 	    };
1384 	
1385 	  template<typename _Tp, typename _Up, size_t __size>
1386 	    struct __tuple_compare<_Tp, _Up, __size, __size>
1387 	    {
1388 	      static constexpr bool
1389 	      __eq(const _Tp&, const _Up&) { return true; }
1390 	
1391 	      static constexpr bool
1392 	      __less(const _Tp&, const _Up&) { return false; }
1393 	    };
1394 	
1395 	  template<typename... _TElements, typename... _UElements>
1396 	    constexpr bool
1397 	    operator==(const tuple<_TElements...>& __t,
1398 		       const tuple<_UElements...>& __u)
1399 	    {
1400 	      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
1401 		  "tuple objects can only be compared if they have equal sizes.");
1402 	      using __compare = __tuple_compare<tuple<_TElements...>,
1403 						tuple<_UElements...>,
1404 						0, sizeof...(_TElements)>;
1405 	      return __compare::__eq(__t, __u);
1406 	    }
1407 	
1408 	  template<typename... _TElements, typename... _UElements>
1409 	    constexpr bool
1410 	    operator<(const tuple<_TElements...>& __t,
1411 		      const tuple<_UElements...>& __u)
1412 	    {
1413 	      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
1414 		  "tuple objects can only be compared if they have equal sizes.");
1415 	      using __compare = __tuple_compare<tuple<_TElements...>,
1416 						tuple<_UElements...>,
1417 						0, sizeof...(_TElements)>;
1418 	      return __compare::__less(__t, __u);
1419 	    }
1420 	
1421 	  template<typename... _TElements, typename... _UElements>
1422 	    constexpr bool
1423 	    operator!=(const tuple<_TElements...>& __t,
1424 		       const tuple<_UElements...>& __u)
1425 	    { return !(__t == __u); }
1426 	
1427 	  template<typename... _TElements, typename... _UElements>
1428 	    constexpr bool
1429 	    operator>(const tuple<_TElements...>& __t,
1430 		      const tuple<_UElements...>& __u)
1431 	    { return __u < __t; }
1432 	
1433 	  template<typename... _TElements, typename... _UElements>
1434 	    constexpr bool
1435 	    operator<=(const tuple<_TElements...>& __t,
1436 		       const tuple<_UElements...>& __u)
1437 	    { return !(__u < __t); }
1438 	
1439 	  template<typename... _TElements, typename... _UElements>
1440 	    constexpr bool
1441 	    operator>=(const tuple<_TElements...>& __t,
1442 		       const tuple<_UElements...>& __u)
1443 	    { return !(__t < __u); }
1444 	
1445 	  // NB: DR 705.
1446 	  template<typename... _Elements>
1447 	    constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
1448 	    make_tuple(_Elements&&... __args)
1449 	    {
1450 	      typedef tuple<typename __decay_and_strip<_Elements>::__type...>
1451 		__result_type;
1452 	      return __result_type(std::forward<_Elements>(__args)...);
1453 	    }
1454 	
1455 	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1456 	  // 2275. Why is forward_as_tuple not constexpr?
1457 	  template<typename... _Elements>
1458 	    constexpr tuple<_Elements&&...>
1459 	    forward_as_tuple(_Elements&&... __args) noexcept
1460 	    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
1461 	
1462 	  template<size_t, typename, typename, size_t>
1463 	    struct __make_tuple_impl;
1464 	
1465 	  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
1466 	    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
1467 	    : __make_tuple_impl<_Idx + 1,
1468 				tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
1469 				_Tuple, _Nm>
1470 	    { };
1471 	
1472 	  template<std::size_t _Nm, typename _Tuple, typename... _Tp>
1473 	    struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
1474 	    {
1475 	      typedef tuple<_Tp...> __type;
1476 	    };
1477 	
1478 	  template<typename _Tuple>
1479 	    struct __do_make_tuple
1480 	    : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
1481 	    { };
1482 	
1483 	  // Returns the std::tuple equivalent of a tuple-like type.
1484 	  template<typename _Tuple>
1485 	    struct __make_tuple
1486 	    : public __do_make_tuple<typename std::remove_cv
1487 	            <typename std::remove_reference<_Tuple>::type>::type>
1488 	    { };
1489 	
1490 	  // Combines several std::tuple's into a single one.
1491 	  template<typename...>
1492 	    struct __combine_tuples;
1493 	
1494 	  template<>
1495 	    struct __combine_tuples<>
1496 	    {
1497 	      typedef tuple<> __type;
1498 	    };
1499 	
1500 	  template<typename... _Ts>
1501 	    struct __combine_tuples<tuple<_Ts...>>
1502 	    {
1503 	      typedef tuple<_Ts...> __type;
1504 	    };
1505 	
1506 	  template<typename... _T1s, typename... _T2s, typename... _Rem>
1507 	    struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
1508 	    {
1509 	      typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
1510 						_Rem...>::__type __type;
1511 	    };
1512 	
1513 	  // Computes the result type of tuple_cat given a set of tuple-like types.
1514 	  template<typename... _Tpls>
1515 	    struct __tuple_cat_result
1516 	    {
1517 	      typedef typename __combine_tuples
1518 	        <typename __make_tuple<_Tpls>::__type...>::__type __type;
1519 	    };
1520 	
1521 	  // Helper to determine the index set for the first tuple-like
1522 	  // type of a given set.
1523 	  template<typename...>
1524 	    struct __make_1st_indices;
1525 	
1526 	  template<>
1527 	    struct __make_1st_indices<>
1528 	    {
1529 	      typedef std::_Index_tuple<> __type;
1530 	    };
1531 	
1532 	  template<typename _Tp, typename... _Tpls>
1533 	    struct __make_1st_indices<_Tp, _Tpls...>
1534 	    {
1535 	      typedef typename std::_Build_index_tuple<std::tuple_size<
1536 		typename std::remove_reference<_Tp>::type>::value>::__type __type;
1537 	    };
1538 	
1539 	  // Performs the actual concatenation by step-wise expanding tuple-like
1540 	  // objects into the elements,  which are finally forwarded into the
1541 	  // result tuple.
1542 	  template<typename _Ret, typename _Indices, typename... _Tpls>
1543 	    struct __tuple_concater;
1544 	
1545 	  template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
1546 	    struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
1547 	    {
1548 	      template<typename... _Us>
1549 	        static constexpr _Ret
1550 	        _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
1551 	        {
1552 		  typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1553 		  typedef __tuple_concater<_Ret, __idx, _Tpls...>      __next;
1554 		  return __next::_S_do(std::forward<_Tpls>(__tps)...,
1555 				       std::forward<_Us>(__us)...,
1556 				       std::get<_Is>(std::forward<_Tp>(__tp))...);
1557 		}
1558 	    };
1559 	
1560 	  template<typename _Ret>
1561 	    struct __tuple_concater<_Ret, std::_Index_tuple<>>
1562 	    {
1563 	      template<typename... _Us>
1564 		static constexpr _Ret
1565 		_S_do(_Us&&... __us)
1566 	        {
1567 		  return _Ret(std::forward<_Us>(__us)...);
1568 		}
1569 	    };
1570 	
1571 	  /// tuple_cat
1572 	  template<typename... _Tpls, typename = typename
1573 	           enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
1574 	    constexpr auto
1575 	    tuple_cat(_Tpls&&... __tpls)
1576 	    -> typename __tuple_cat_result<_Tpls...>::__type
1577 	    {
1578 	      typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
1579 	      typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1580 	      typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
1581 	      return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
1582 	    }
1583 	
1584 	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1585 	  // 2301. Why is tie not constexpr?
1586 	  /// tie
1587 	  template<typename... _Elements>
1588 	    constexpr tuple<_Elements&...>
1589 	    tie(_Elements&... __args) noexcept
1590 	    { return tuple<_Elements&...>(__args...); }
1591 	
1592 	  /// swap
1593 	  template<typename... _Elements>
1594 	    inline
1595 	#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
1596 	    // Constrained free swap overload, see p0185r1
1597 	    typename enable_if<__and_<__is_swappable<_Elements>...>::value
1598 	      >::type
1599 	#else
1600 	    void
1601 	#endif
1602 	    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
1603 	    noexcept(noexcept(__x.swap(__y)))
1604 	    { __x.swap(__y); }
1605 	
1606 	#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
1607 	  template<typename... _Elements>
1608 	    typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
1609 	    swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
1610 	#endif
1611 	
1612 	  // A class (and instance) which can be used in 'tie' when an element
1613 	  // of a tuple is not required.
1614 	  // _GLIBCXX14_CONSTEXPR
1615 	  // 2933. PR for LWG 2773 could be clearer
1616 	  struct _Swallow_assign
1617 	  {
1618 	    template<class _Tp>
1619 	      _GLIBCXX14_CONSTEXPR const _Swallow_assign&
1620 	      operator=(const _Tp&) const
1621 	      { return *this; }
1622 	  };
1623 	
1624 	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1625 	  // 2773. Making std::ignore constexpr
1626 	  _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{};
1627 	
1628 	  /// Partial specialization for tuples
1629 	  template<typename... _Types, typename _Alloc>
1630 	    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
1631 	
1632 	  // See stl_pair.h...
1633 	  template<class _T1, class _T2>
1634 	    template<typename... _Args1, typename... _Args2>
1635 	      inline
1636 	      pair<_T1, _T2>::
1637 	      pair(piecewise_construct_t,
1638 		   tuple<_Args1...> __first, tuple<_Args2...> __second)
1639 	      : pair(__first, __second,
1640 		     typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
1641 		     typename _Build_index_tuple<sizeof...(_Args2)>::__type())
1642 	      { }
1643 	
1644 	  template<class _T1, class _T2>
1645 	    template<typename... _Args1, std::size_t... _Indexes1,
1646 	             typename... _Args2, std::size_t... _Indexes2>
1647 	      inline
1648 	      pair<_T1, _T2>::
1649 	      pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
1650 		   _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
1651 	      : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
1652 	        second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
1653 	      { }
1654 	
1655 	#if __cplusplus > 201402L
1656 	# define __cpp_lib_apply 201603
1657 	
1658 	  template <typename _Fn, typename _Tuple, size_t... _Idx>
1659 	    constexpr decltype(auto)
1660 	    __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
1661 	    {
1662 	      return std::__invoke(std::forward<_Fn>(__f),
1663 				   std::get<_Idx>(std::forward<_Tuple>(__t))...);
1664 	    }
1665 	
1666 	  template <typename _Fn, typename _Tuple>
1667 	    constexpr decltype(auto)
1668 	    apply(_Fn&& __f, _Tuple&& __t)
1669 	    {
1670 	      using _Indices = make_index_sequence<tuple_size_v<decay_t<_Tuple>>>;
1671 	      return std::__apply_impl(std::forward<_Fn>(__f),
1672 				       std::forward<_Tuple>(__t),
1673 				       _Indices{});
1674 	    }
1675 	
1676 	#define __cpp_lib_make_from_tuple  201606
1677 	
1678 	  template <typename _Tp, typename _Tuple, size_t... _Idx>
1679 	    constexpr _Tp
1680 	    __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
1681 	    { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }
1682 	
1683 	  template <typename _Tp, typename _Tuple>
1684 	    constexpr _Tp
1685 	    make_from_tuple(_Tuple&& __t)
1686 	    {
1687 	      return __make_from_tuple_impl<_Tp>(
1688 	        std::forward<_Tuple>(__t),
1689 		make_index_sequence<tuple_size_v<decay_t<_Tuple>>>{});
1690 	    }
1691 	#endif // C++17
1692 	
1693 	  /// @}
1694 	
1695 	_GLIBCXX_END_NAMESPACE_VERSION
1696 	} // namespace std
1697 	
1698 	#endif // C++11
1699 	
1700 	#endif // _GLIBCXX_TUPLE
1701