1    	// C++11 <type_traits> -*- 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/type_traits
26   	 *  This is a Standard C++ Library header.
27   	 */
28   	
29   	#ifndef _GLIBCXX_TYPE_TRAITS
30   	#define _GLIBCXX_TYPE_TRAITS 1
31   	
32   	#pragma GCC system_header
33   	
34   	#if __cplusplus < 201103L
35   	# include <bits/c++0x_warning.h>
36   	#else
37   	
38   	#include <bits/c++config.h>
39   	
40   	#ifdef _GLIBCXX_USE_C99_STDINT_TR1
41   	# if defined (__UINT_LEAST16_TYPE__) && defined(__UINT_LEAST32_TYPE__)
42   	namespace std
43   	{
44   	  typedef __UINT_LEAST16_TYPE__ uint_least16_t;
45   	  typedef __UINT_LEAST32_TYPE__ uint_least32_t;
46   	}
47   	# else
48   	#  include <cstdint>
49   	# endif
50   	#endif
51   	
52   	namespace std _GLIBCXX_VISIBILITY(default)
53   	{
54   	_GLIBCXX_BEGIN_NAMESPACE_VERSION
55   	
56   	  /**
57   	   * @defgroup metaprogramming Metaprogramming
58   	   * @ingroup utilities
59   	   *
60   	   * Template utilities for compile-time introspection and modification,
61   	   * including type classification traits, type property inspection traits
62   	   * and type transformation traits.
63   	   *
64   	   * @{
65   	   */
66   	
67   	  /// integral_constant
68   	  template<typename _Tp, _Tp __v>
69   	    struct integral_constant
70   	    {
71   	      static constexpr _Tp                  value = __v;
72   	      typedef _Tp                           value_type;
73   	      typedef integral_constant<_Tp, __v>   type;
74   	      constexpr operator value_type() const noexcept { return value; }
75   	#if __cplusplus > 201103L
76   	
77   	#define __cpp_lib_integral_constant_callable 201304
78   	
79   	      constexpr value_type operator()() const noexcept { return value; }
80   	#endif
81   	    };
82   	
83   	  template<typename _Tp, _Tp __v>
84   	    constexpr _Tp integral_constant<_Tp, __v>::value;
85   	
86   	  /// The type used as a compile-time boolean with true value.
87   	  typedef integral_constant<bool, true>     true_type;
88   	
89   	  /// The type used as a compile-time boolean with false value.
90   	  typedef integral_constant<bool, false>    false_type;
91   	
92   	  template<bool __v>
93   	    using __bool_constant = integral_constant<bool, __v>;
94   	
95   	#if __cplusplus > 201402L
96   	# define __cpp_lib_bool_constant 201505
97   	  template<bool __v>
98   	    using bool_constant = integral_constant<bool, __v>;
99   	#endif
100  	
101  	  // Meta programming helper types.
102  	
103  	  template<bool, typename, typename>
104  	    struct conditional;
105  	
106  	  template<typename...>
107  	    struct __or_;
108  	
109  	  template<>
110  	    struct __or_<>
111  	    : public false_type
112  	    { };
113  	
114  	  template<typename _B1>
115  	    struct __or_<_B1>
116  	    : public _B1
117  	    { };
118  	
119  	  template<typename _B1, typename _B2>
120  	    struct __or_<_B1, _B2>
121  	    : public conditional<_B1::value, _B1, _B2>::type
122  	    { };
123  	
124  	  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
125  	    struct __or_<_B1, _B2, _B3, _Bn...>
126  	    : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
127  	    { };
128  	
129  	  template<typename...>
130  	    struct __and_;
131  	
132  	  template<>
133  	    struct __and_<>
134  	    : public true_type
135  	    { };
136  	
137  	  template<typename _B1>
138  	    struct __and_<_B1>
139  	    : public _B1
140  	    { };
141  	
142  	  template<typename _B1, typename _B2>
143  	    struct __and_<_B1, _B2>
144  	    : public conditional<_B1::value, _B2, _B1>::type
145  	    { };
146  	
147  	  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
148  	    struct __and_<_B1, _B2, _B3, _Bn...>
149  	    : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
150  	    { };
151  	
152  	  template<typename _Pp>
153  	    struct __not_
154  	    : public __bool_constant<!bool(_Pp::value)>
155  	    { };
156  	
157  	#if __cplusplus >= 201703L
158  	
159  	#define __cpp_lib_logical_traits 201510
160  	
161  	  template<typename... _Bn>
162  	    struct conjunction
163  	    : __and_<_Bn...>
164  	    { };
165  	
166  	  template<typename... _Bn>
167  	    struct disjunction
168  	    : __or_<_Bn...>
169  	    { };
170  	
171  	  template<typename _Pp>
172  	    struct negation
173  	    : __not_<_Pp>
174  	    { };
175  	
176  	  template<typename... _Bn>
177  	    inline constexpr bool conjunction_v = conjunction<_Bn...>::value;
178  	
179  	  template<typename... _Bn>
180  	    inline constexpr bool disjunction_v = disjunction<_Bn...>::value;
181  	
182  	  template<typename _Pp>
183  	    inline constexpr bool negation_v = negation<_Pp>::value;
184  	
185  	#endif // C++17
186  	
187  	  // For several sfinae-friendly trait implementations we transport both the
188  	  // result information (as the member type) and the failure information (no
189  	  // member type). This is very similar to std::enable_if, but we cannot use
190  	  // them, because we need to derive from them as an implementation detail.
191  	
192  	  template<typename _Tp>
193  	    struct __success_type
194  	    { typedef _Tp type; };
195  	
196  	  struct __failure_type
197  	  { };
198  	
199  	  // Primary type categories.
200  	
201  	  template<typename>
202  	    struct remove_cv;
203  	
204  	  template<typename>
205  	    struct __is_void_helper
206  	    : public false_type { };
207  	
208  	  template<>
209  	    struct __is_void_helper<void>
210  	    : public true_type { };
211  	
212  	  /// is_void
213  	  template<typename _Tp>
214  	    struct is_void
215  	    : public __is_void_helper<typename remove_cv<_Tp>::type>::type
216  	    { };
217  	
218  	  template<typename>
219  	    struct __is_integral_helper
220  	    : public false_type { };
221  	
222  	  template<>
223  	    struct __is_integral_helper<bool>
224  	    : public true_type { };
225  	
226  	  template<>
227  	    struct __is_integral_helper<char>
228  	    : public true_type { };
229  	
230  	  template<>
231  	    struct __is_integral_helper<signed char>
232  	    : public true_type { };
233  	
234  	  template<>
235  	    struct __is_integral_helper<unsigned char>
236  	    : public true_type { };
237  	
238  	#ifdef _GLIBCXX_USE_WCHAR_T
239  	  template<>
240  	    struct __is_integral_helper<wchar_t>
241  	    : public true_type { };
242  	#endif
243  	
244  	  template<>
245  	    struct __is_integral_helper<char16_t>
246  	    : public true_type { };
247  	
248  	  template<>
249  	    struct __is_integral_helper<char32_t>
250  	    : public true_type { };
251  	
252  	  template<>
253  	    struct __is_integral_helper<short>
254  	    : public true_type { };
255  	
256  	  template<>
257  	    struct __is_integral_helper<unsigned short>
258  	    : public true_type { };
259  	
260  	  template<>
261  	    struct __is_integral_helper<int>
262  	    : public true_type { };
263  	
264  	  template<>
265  	    struct __is_integral_helper<unsigned int>
266  	    : public true_type { };
267  	
268  	  template<>
269  	    struct __is_integral_helper<long>
270  	    : public true_type { };
271  	
272  	  template<>
273  	    struct __is_integral_helper<unsigned long>
274  	    : public true_type { };
275  	
276  	  template<>
277  	    struct __is_integral_helper<long long>
278  	    : public true_type { };
279  	
280  	  template<>
281  	    struct __is_integral_helper<unsigned long long>
282  	    : public true_type { };
283  	
284  	  // Conditionalizing on __STRICT_ANSI__ here will break any port that
285  	  // uses one of these types for size_t.
286  	#if defined(__GLIBCXX_TYPE_INT_N_0)
287  	  template<>
288  	    struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_0>
289  	    : public true_type { };
290  	
291  	  template<>
292  	    struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_0>
293  	    : public true_type { };
294  	#endif
295  	#if defined(__GLIBCXX_TYPE_INT_N_1)
296  	  template<>
297  	    struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_1>
298  	    : public true_type { };
299  	
300  	  template<>
301  	    struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_1>
302  	    : public true_type { };
303  	#endif
304  	#if defined(__GLIBCXX_TYPE_INT_N_2)
305  	  template<>
306  	    struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_2>
307  	    : public true_type { };
308  	
309  	  template<>
310  	    struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_2>
311  	    : public true_type { };
312  	#endif
313  	#if defined(__GLIBCXX_TYPE_INT_N_3)
314  	  template<>
315  	    struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_3>
316  	    : public true_type { };
317  	
318  	  template<>
319  	    struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_3>
320  	    : public true_type { };
321  	#endif
322  	
323  	  /// is_integral
324  	  template<typename _Tp>
325  	    struct is_integral
326  	    : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
327  	    { };
328  	
329  	  template<typename>
330  	    struct __is_floating_point_helper
331  	    : public false_type { };
332  	
333  	  template<>
334  	    struct __is_floating_point_helper<float>
335  	    : public true_type { };
336  	
337  	  template<>
338  	    struct __is_floating_point_helper<double>
339  	    : public true_type { };
340  	
341  	  template<>
342  	    struct __is_floating_point_helper<long double>
343  	    : public true_type { };
344  	
345  	#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128)
346  	  template<>
347  	    struct __is_floating_point_helper<__float128>
348  	    : public true_type { };
349  	#endif
350  	
351  	  /// is_floating_point
352  	  template<typename _Tp>
353  	    struct is_floating_point
354  	    : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
355  	    { };
356  	
357  	  /// is_array
358  	  template<typename>
359  	    struct is_array
360  	    : public false_type { };
361  	
362  	  template<typename _Tp, std::size_t _Size>
363  	    struct is_array<_Tp[_Size]>
364  	    : public true_type { };
365  	
366  	  template<typename _Tp>
367  	    struct is_array<_Tp[]>
368  	    : public true_type { };
369  	
370  	  template<typename>
371  	    struct __is_pointer_helper
372  	    : public false_type { };
373  	
374  	  template<typename _Tp>
375  	    struct __is_pointer_helper<_Tp*>
376  	    : public true_type { };
377  	
378  	  /// is_pointer
379  	  template<typename _Tp>
380  	    struct is_pointer
381  	    : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
382  	    { };
383  	
384  	  /// is_lvalue_reference
385  	  template<typename>
386  	    struct is_lvalue_reference
387  	    : public false_type { };
388  	
389  	  template<typename _Tp>
390  	    struct is_lvalue_reference<_Tp&>
391  	    : public true_type { };
392  	
393  	  /// is_rvalue_reference
394  	  template<typename>
395  	    struct is_rvalue_reference
396  	    : public false_type { };
397  	
398  	  template<typename _Tp>
399  	    struct is_rvalue_reference<_Tp&&>
400  	    : public true_type { };
401  	
402  	  template<typename>
403  	    struct is_function;
404  	
405  	  template<typename>
406  	    struct __is_member_object_pointer_helper
407  	    : public false_type { };
408  	
409  	  template<typename _Tp, typename _Cp>
410  	    struct __is_member_object_pointer_helper<_Tp _Cp::*>
411  	    : public integral_constant<bool, !is_function<_Tp>::value> { };
412  	
413  	  /// is_member_object_pointer
414  	  template<typename _Tp>
415  	    struct is_member_object_pointer
416  	    : public __is_member_object_pointer_helper<
417  					typename remove_cv<_Tp>::type>::type
418  	    { };
419  	
420  	  template<typename>
421  	    struct __is_member_function_pointer_helper
422  	    : public false_type { };
423  	
424  	  template<typename _Tp, typename _Cp>
425  	    struct __is_member_function_pointer_helper<_Tp _Cp::*>
426  	    : public integral_constant<bool, is_function<_Tp>::value> { };
427  	
428  	  /// is_member_function_pointer
429  	  template<typename _Tp>
430  	    struct is_member_function_pointer
431  	    : public __is_member_function_pointer_helper<
432  					typename remove_cv<_Tp>::type>::type
433  	    { };
434  	
435  	  /// is_enum
436  	  template<typename _Tp>
437  	    struct is_enum
438  	    : public integral_constant<bool, __is_enum(_Tp)>
439  	    { };
440  	
441  	  /// is_union
442  	  template<typename _Tp>
443  	    struct is_union
444  	    : public integral_constant<bool, __is_union(_Tp)>
445  	    { };
446  	
447  	  /// is_class
448  	  template<typename _Tp>
449  	    struct is_class
450  	    : public integral_constant<bool, __is_class(_Tp)>
451  	    { };
452  	
453  	  /// is_function
454  	  template<typename>
455  	    struct is_function
456  	    : public false_type { };
457  	
458  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
459  	    struct is_function<_Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL>
460  	    : public true_type { };
461  	
462  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
463  	    struct is_function<_Res(_ArgTypes...) & _GLIBCXX_NOEXCEPT_QUAL>
464  	    : public true_type { };
465  	
466  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
467  	    struct is_function<_Res(_ArgTypes...) && _GLIBCXX_NOEXCEPT_QUAL>
468  	    : public true_type { };
469  	
470  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
471  	    struct is_function<_Res(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL>
472  	    : public true_type { };
473  	
474  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
475  	    struct is_function<_Res(_ArgTypes......) & _GLIBCXX_NOEXCEPT_QUAL>
476  	    : public true_type { };
477  	
478  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
479  	    struct is_function<_Res(_ArgTypes......) && _GLIBCXX_NOEXCEPT_QUAL>
480  	    : public true_type { };
481  	
482  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
483  	    struct is_function<_Res(_ArgTypes...) const _GLIBCXX_NOEXCEPT_QUAL>
484  	    : public true_type { };
485  	
486  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
487  	    struct is_function<_Res(_ArgTypes...) const & _GLIBCXX_NOEXCEPT_QUAL>
488  	    : public true_type { };
489  	
490  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
491  	    struct is_function<_Res(_ArgTypes...) const && _GLIBCXX_NOEXCEPT_QUAL>
492  	    : public true_type { };
493  	
494  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
495  	    struct is_function<_Res(_ArgTypes......) const _GLIBCXX_NOEXCEPT_QUAL>
496  	    : public true_type { };
497  	
498  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
499  	    struct is_function<_Res(_ArgTypes......) const & _GLIBCXX_NOEXCEPT_QUAL>
500  	    : public true_type { };
501  	
502  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
503  	    struct is_function<_Res(_ArgTypes......) const && _GLIBCXX_NOEXCEPT_QUAL>
504  	    : public true_type { };
505  	
506  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
507  	    struct is_function<_Res(_ArgTypes...) volatile _GLIBCXX_NOEXCEPT_QUAL>
508  	    : public true_type { };
509  	
510  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
511  	    struct is_function<_Res(_ArgTypes...) volatile & _GLIBCXX_NOEXCEPT_QUAL>
512  	    : public true_type { };
513  	
514  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
515  	    struct is_function<_Res(_ArgTypes...) volatile && _GLIBCXX_NOEXCEPT_QUAL>
516  	    : public true_type { };
517  	
518  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
519  	    struct is_function<_Res(_ArgTypes......) volatile _GLIBCXX_NOEXCEPT_QUAL>
520  	    : public true_type { };
521  	
522  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
523  	    struct is_function<_Res(_ArgTypes......) volatile & _GLIBCXX_NOEXCEPT_QUAL>
524  	    : public true_type { };
525  	
526  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
527  	    struct is_function<_Res(_ArgTypes......) volatile && _GLIBCXX_NOEXCEPT_QUAL>
528  	    : public true_type { };
529  	
530  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
531  	    struct is_function<_Res(_ArgTypes...) const volatile _GLIBCXX_NOEXCEPT_QUAL>
532  	    : public true_type { };
533  	
534  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
535  	    struct is_function<_Res(_ArgTypes...) const volatile & _GLIBCXX_NOEXCEPT_QUAL>
536  	    : public true_type { };
537  	
538  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
539  	    struct is_function<_Res(_ArgTypes...) const volatile && _GLIBCXX_NOEXCEPT_QUAL>
540  	    : public true_type { };
541  	
542  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
543  	    struct is_function<_Res(_ArgTypes......) const volatile _GLIBCXX_NOEXCEPT_QUAL>
544  	    : public true_type { };
545  	
546  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
547  	    struct is_function<_Res(_ArgTypes......) const volatile & _GLIBCXX_NOEXCEPT_QUAL>
548  	    : public true_type { };
549  	
550  	  template<typename _Res, typename... _ArgTypes _GLIBCXX_NOEXCEPT_PARM>
551  	    struct is_function<_Res(_ArgTypes......) const volatile && _GLIBCXX_NOEXCEPT_QUAL>
552  	    : public true_type { };
553  	
554  	#define __cpp_lib_is_null_pointer 201309
555  	
556  	  template<typename>
557  	    struct __is_null_pointer_helper
558  	    : public false_type { };
559  	
560  	  template<>
561  	    struct __is_null_pointer_helper<std::nullptr_t>
562  	    : public true_type { };
563  	
564  	  /// is_null_pointer (LWG 2247).
565  	  template<typename _Tp>
566  	    struct is_null_pointer
567  	    : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
568  	    { };
569  	
570  	  /// __is_nullptr_t (extension).
571  	  template<typename _Tp>
572  	    struct __is_nullptr_t
573  	    : public is_null_pointer<_Tp>
574  	    { };
575  	
576  	  // Composite type categories.
577  	
578  	  /// is_reference
579  	  template<typename _Tp>
580  	    struct is_reference
581  	    : public __or_<is_lvalue_reference<_Tp>,
582  	                   is_rvalue_reference<_Tp>>::type
583  	    { };
584  	
585  	  /// is_arithmetic
586  	  template<typename _Tp>
587  	    struct is_arithmetic
588  	    : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
589  	    { };
590  	
591  	  /// is_fundamental
592  	  template<typename _Tp>
593  	    struct is_fundamental
594  	    : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
595  			   is_null_pointer<_Tp>>::type
596  	    { };
597  	
598  	  /// is_object
599  	  template<typename _Tp>
600  	    struct is_object
601  	    : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602  	                          is_void<_Tp>>>::type
603  	    { };
604  	
605  	  template<typename>
606  	    struct is_member_pointer;
607  	
608  	  /// is_scalar
609  	  template<typename _Tp>
610  	    struct is_scalar
611  	    : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
612  	                   is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
613  	    { };
614  	
615  	  /// is_compound
616  	  template<typename _Tp>
617  	    struct is_compound
618  	    : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
619  	
620  	  template<typename _Tp>
621  	    struct __is_member_pointer_helper
622  	    : public false_type { };
623  	
624  	  template<typename _Tp, typename _Cp>
625  	    struct __is_member_pointer_helper<_Tp _Cp::*>
626  	    : public true_type { };
627  	
628  	  /// is_member_pointer
629  	  template<typename _Tp>
630  	    struct is_member_pointer
631  	    : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
632  	    { };
633  	
634  	  // Utility to detect referenceable types ([defns.referenceable]).
635  	
636  	  template<typename _Tp>
637  	    struct __is_referenceable
638  	    : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
639  	    { };
640  	
641  	  template<typename _Res, typename... _Args _GLIBCXX_NOEXCEPT_PARM>
642  	    struct __is_referenceable<_Res(_Args...) _GLIBCXX_NOEXCEPT_QUAL>
643  	    : public true_type
644  	    { };
645  	
646  	  template<typename _Res, typename... _Args _GLIBCXX_NOEXCEPT_PARM>
647  	    struct __is_referenceable<_Res(_Args......) _GLIBCXX_NOEXCEPT_QUAL>
648  	    : public true_type
649  	    { };
650  	
651  	  // Type properties.
652  	
653  	  /// is_const
654  	  template<typename>
655  	    struct is_const
656  	    : public false_type { };
657  	
658  	  template<typename _Tp>
659  	    struct is_const<_Tp const>
660  	    : public true_type { };
661  	
662  	  /// is_volatile
663  	  template<typename>
664  	    struct is_volatile
665  	    : public false_type { };
666  	
667  	  template<typename _Tp>
668  	    struct is_volatile<_Tp volatile>
669  	    : public true_type { };
670  	
671  	  /// is_trivial
672  	  template<typename _Tp>
673  	    struct is_trivial
674  	    : public integral_constant<bool, __is_trivial(_Tp)>
675  	    { };
676  	
677  	  // is_trivially_copyable
678  	  template<typename _Tp>
679  	    struct is_trivially_copyable
680  	    : public integral_constant<bool, __is_trivially_copyable(_Tp)>
681  	    { };
682  	
683  	  /// is_standard_layout
684  	  template<typename _Tp>
685  	    struct is_standard_layout
686  	    : public integral_constant<bool, __is_standard_layout(_Tp)>
687  	    { };
688  	
689  	  /// is_pod
690  	  // Could use is_standard_layout && is_trivial instead of the builtin.
691  	  template<typename _Tp>
692  	    struct is_pod
693  	    : public integral_constant<bool, __is_pod(_Tp)>
694  	    { };
695  	
696  	  /// is_literal_type
697  	  template<typename _Tp>
698  	    struct is_literal_type
699  	    : public integral_constant<bool, __is_literal_type(_Tp)>
700  	    { };
701  	
702  	  /// is_empty
703  	  template<typename _Tp>
704  	    struct is_empty
705  	    : public integral_constant<bool, __is_empty(_Tp)>
706  	    { };
707  	
708  	  /// is_polymorphic
709  	  template<typename _Tp>
710  	    struct is_polymorphic
711  	    : public integral_constant<bool, __is_polymorphic(_Tp)>
712  	    { };
713  	
714  	#if __cplusplus >= 201402L
715  	#define __cpp_lib_is_final 201402L
716  	  /// is_final
717  	  template<typename _Tp>
718  	    struct is_final
719  	    : public integral_constant<bool, __is_final(_Tp)>
720  	    { };
721  	#endif
722  	
723  	  /// is_abstract
724  	  template<typename _Tp>
725  	    struct is_abstract
726  	    : public integral_constant<bool, __is_abstract(_Tp)>
727  	    { };
728  	
729  	  template<typename _Tp,
730  		   bool = is_arithmetic<_Tp>::value>
731  	    struct __is_signed_helper
732  	    : public false_type { };
733  	
734  	  template<typename _Tp>
735  	    struct __is_signed_helper<_Tp, true>
736  	    : public integral_constant<bool, _Tp(-1) < _Tp(0)>
737  	    { };
738  	
739  	  /// is_signed
740  	  template<typename _Tp>
741  	    struct is_signed
742  	    : public __is_signed_helper<_Tp>::type
743  	    { };
744  	
745  	  /// is_unsigned
746  	  template<typename _Tp>
747  	    struct is_unsigned
748  	    : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
749  	    { };
750  	
751  	
752  	  // Destructible and constructible type properties.
753  	
754  	  template<typename>
755  	    struct add_rvalue_reference;
756  	
757  	  /**
758  	   *  @brief  Utility to simplify expressions used in unevaluated operands
759  	   *  @ingroup utilities
760  	   */
761  	  template<typename _Tp>
762  	    typename add_rvalue_reference<_Tp>::type declval() noexcept;
763  	
764  	  template<typename, unsigned = 0>
765  	    struct extent;
766  	
767  	  template<typename>
768  	    struct remove_all_extents;
769  	
770  	  template<typename _Tp>
771  	    struct __is_array_known_bounds
772  	    : public integral_constant<bool, (extent<_Tp>::value > 0)>
773  	    { };
774  	
775  	  template<typename _Tp>
776  	    struct __is_array_unknown_bounds
777  	    : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
778  	    { };
779  	
780  	  // In N3290 is_destructible does not say anything about function
781  	  // types and abstract types, see LWG 2049. This implementation
782  	  // describes function types as non-destructible and all complete
783  	  // object types as destructible, iff the explicit destructor
784  	  // call expression is wellformed.
785  	  struct __do_is_destructible_impl
786  	  {
787  	    template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
788  	      static true_type __test(int);
789  	
790  	    template<typename>
791  	      static false_type __test(...);
792  	  };
793  	
794  	  template<typename _Tp>
795  	    struct __is_destructible_impl
796  	    : public __do_is_destructible_impl
797  	    {
798  	      typedef decltype(__test<_Tp>(0)) type;
799  	    };
800  	
801  	  template<typename _Tp,
802  	           bool = __or_<is_void<_Tp>,
803  	                        __is_array_unknown_bounds<_Tp>,
804  	                        is_function<_Tp>>::value,
805  	           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
806  	    struct __is_destructible_safe;
807  	
808  	  template<typename _Tp>
809  	    struct __is_destructible_safe<_Tp, false, false>
810  	    : public __is_destructible_impl<typename
811  	               remove_all_extents<_Tp>::type>::type
812  	    { };
813  	
814  	  template<typename _Tp>
815  	    struct __is_destructible_safe<_Tp, true, false>
816  	    : public false_type { };
817  	
818  	  template<typename _Tp>
819  	    struct __is_destructible_safe<_Tp, false, true>
820  	    : public true_type { };
821  	
822  	  /// is_destructible
823  	  template<typename _Tp>
824  	    struct is_destructible
825  	    : public __is_destructible_safe<_Tp>::type
826  	    { };
827  	
828  	  // is_nothrow_destructible requires that is_destructible is
829  	  // satisfied as well.  We realize that by mimicing the
830  	  // implementation of is_destructible but refer to noexcept(expr)
831  	  // instead of decltype(expr).
832  	  struct __do_is_nt_destructible_impl
833  	  {
834  	    template<typename _Tp>
835  	      static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
836  	        __test(int);
837  	
838  	    template<typename>
839  	      static false_type __test(...);
840  	  };
841  	
842  	  template<typename _Tp>
843  	    struct __is_nt_destructible_impl
844  	    : public __do_is_nt_destructible_impl
845  	    {
846  	      typedef decltype(__test<_Tp>(0)) type;
847  	    };
848  	
849  	  template<typename _Tp,
850  	           bool = __or_<is_void<_Tp>,
851  	                        __is_array_unknown_bounds<_Tp>,
852  	                        is_function<_Tp>>::value,
853  	           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
854  	    struct __is_nt_destructible_safe;
855  	
856  	  template<typename _Tp>
857  	    struct __is_nt_destructible_safe<_Tp, false, false>
858  	    : public __is_nt_destructible_impl<typename
859  	               remove_all_extents<_Tp>::type>::type
860  	    { };
861  	
862  	  template<typename _Tp>
863  	    struct __is_nt_destructible_safe<_Tp, true, false>
864  	    : public false_type { };
865  	
866  	  template<typename _Tp>
867  	    struct __is_nt_destructible_safe<_Tp, false, true>
868  	    : public true_type { };
869  	
870  	  /// is_nothrow_destructible
871  	  template<typename _Tp>
872  	    struct is_nothrow_destructible
873  	    : public __is_nt_destructible_safe<_Tp>::type
874  	    { };
875  	
876  	  struct __do_is_default_constructible_impl
877  	  {
878  	    template<typename _Tp, typename = decltype(_Tp())>
879  	      static true_type __test(int);
880  	
881  	    template<typename>
882  	      static false_type __test(...);
883  	  };
884  	
885  	  template<typename _Tp>
886  	    struct __is_default_constructible_impl
887  	    : public __do_is_default_constructible_impl
888  	    {
889  	      typedef decltype(__test<_Tp>(0)) type;
890  	    };
891  	
892  	  template<typename _Tp>
893  	    struct __is_default_constructible_atom
894  	    : public __and_<__not_<is_void<_Tp>>,
895  	                    __is_default_constructible_impl<_Tp>>
896  	    { };
897  	
898  	  template<typename _Tp, bool = is_array<_Tp>::value>
899  	    struct __is_default_constructible_safe;
900  	
901  	  // The following technique is a workaround for a current core language
902  	  // restriction, which does not allow for array types to occur in
903  	  // functional casts of the form T().  Complete arrays can be default-
904  	  // constructed, if the element type is default-constructible, but
905  	  // arrays with unknown bounds are not.
906  	  template<typename _Tp>
907  	    struct __is_default_constructible_safe<_Tp, true>
908  	    : public __and_<__is_array_known_bounds<_Tp>,
909  			    __is_default_constructible_atom<typename
910  	                      remove_all_extents<_Tp>::type>>
911  	    { };
912  	
913  	  template<typename _Tp>
914  	    struct __is_default_constructible_safe<_Tp, false>
915  	    : public __is_default_constructible_atom<_Tp>::type
916  	    { };
917  	
918  	  /// is_default_constructible
919  	  template<typename _Tp>
920  	    struct is_default_constructible
921  	    : public __is_default_constructible_safe<_Tp>::type
922  	    { };
923  	
924  	
925  	  // Implementation of is_constructible.
926  	
927  	  // The hardest part of this trait is the binary direct-initialization
928  	  // case, because we hit into a functional cast of the form T(arg).
929  	  // This implementation uses different strategies depending on the
930  	  // target type to reduce the test overhead as much as possible:
931  	  //
932  	  // a) For a reference target type, we use a static_cast expression
933  	  //    modulo its extra cases.
934  	  //
935  	  // b) For a non-reference target type we use a ::new expression.
936  	  struct __do_is_static_castable_impl
937  	  {
938  	    template<typename _From, typename _To, typename
939  	             = decltype(static_cast<_To>(declval<_From>()))>
940  	      static true_type __test(int);
941  	
942  	    template<typename, typename>
943  	      static false_type __test(...);
944  	  };
945  	
946  	  template<typename _From, typename _To>
947  	    struct __is_static_castable_impl
948  	    : public __do_is_static_castable_impl
949  	    {
950  	      typedef decltype(__test<_From, _To>(0)) type;
951  	    };
952  	
953  	  template<typename _From, typename _To>
954  	    struct __is_static_castable_safe
955  	    : public __is_static_castable_impl<_From, _To>::type
956  	    { };
957  	
958  	  // __is_static_castable
959  	  template<typename _From, typename _To>
960  	    struct __is_static_castable
961  	    : public integral_constant<bool, (__is_static_castable_safe<
962  					      _From, _To>::value)>
963  	    { };
964  	
965  	  // Implementation for non-reference types. To meet the proper
966  	  // variable definition semantics, we also need to test for
967  	  // is_destructible in this case.
968  	  // This form should be simplified by a single expression:
969  	  // ::delete ::new _Tp(declval<_Arg>()), see c++/51222.
970  	  struct __do_is_direct_constructible_impl
971  	  {
972  	    template<typename _Tp, typename _Arg, typename
973  		     = decltype(::new _Tp(declval<_Arg>()))>
974  	      static true_type __test(int);
975  	
976  	    template<typename, typename>
977  	      static false_type __test(...);
978  	  };
979  	
980  	  template<typename _Tp, typename _Arg>
981  	    struct __is_direct_constructible_impl
982  	    : public __do_is_direct_constructible_impl
983  	    {
984  	      typedef decltype(__test<_Tp, _Arg>(0)) type;
985  	    };
986  	
987  	  template<typename _Tp, typename _Arg>
988  	    struct __is_direct_constructible_new_safe
989  	    : public __and_<is_destructible<_Tp>,
990  	                    __is_direct_constructible_impl<_Tp, _Arg>>
991  	    { };
992  	
993  	  template<typename, typename>
994  	    struct is_same;
995  	
996  	  template<typename, typename>
997  	    struct is_base_of;
998  	
999  	  template<typename>
1000 	    struct remove_reference;
1001 	
1002 	  template<typename _From, typename _To, bool
1003 	           = __not_<__or_<is_void<_From>,
1004 	                          is_function<_From>>>::value>
1005 	    struct __is_base_to_derived_ref;
1006 	
1007 	  template<typename _Tp, typename... _Args>
1008 	    struct is_constructible;
1009 	
1010 	  // Detect whether we have a downcast situation during
1011 	  // reference binding.
1012 	  template<typename _From, typename _To>
1013 	    struct __is_base_to_derived_ref<_From, _To, true>
1014 	    {
1015 	      typedef typename remove_cv<typename remove_reference<_From
1016 	        >::type>::type __src_t;
1017 	      typedef typename remove_cv<typename remove_reference<_To
1018 	        >::type>::type __dst_t;
1019 	      typedef __and_<__not_<is_same<__src_t, __dst_t>>,
1020 			     is_base_of<__src_t, __dst_t>,
1021 			     __not_<is_constructible<__dst_t, _From>>> type;
1022 	      static constexpr bool value = type::value;
1023 	    };
1024 	
1025 	  template<typename _From, typename _To>
1026 	    struct __is_base_to_derived_ref<_From, _To, false>
1027 	    : public false_type
1028 	    { };
1029 	
1030 	  template<typename _From, typename _To, bool
1031 	           = __and_<is_lvalue_reference<_From>,
1032 	                    is_rvalue_reference<_To>>::value>
1033 	    struct __is_lvalue_to_rvalue_ref;
1034 	
1035 	  // Detect whether we have an lvalue of non-function type
1036 	  // bound to a reference-compatible rvalue-reference.
1037 	  template<typename _From, typename _To>
1038 	    struct __is_lvalue_to_rvalue_ref<_From, _To, true>
1039 	    {
1040 	      typedef typename remove_cv<typename remove_reference<
1041 	        _From>::type>::type __src_t;
1042 	      typedef typename remove_cv<typename remove_reference<
1043 	        _To>::type>::type __dst_t;
1044 	      typedef __and_<__not_<is_function<__src_t>>,
1045 	        __or_<is_same<__src_t, __dst_t>,
1046 			    is_base_of<__dst_t, __src_t>>> type;
1047 	      static constexpr bool value = type::value;
1048 	    };
1049 	
1050 	  template<typename _From, typename _To>
1051 	    struct __is_lvalue_to_rvalue_ref<_From, _To, false>
1052 	    : public false_type
1053 	    { };
1054 	
1055 	  // Here we handle direct-initialization to a reference type as
1056 	  // equivalent to a static_cast modulo overshooting conversions.
1057 	  // These are restricted to the following conversions:
1058 	  //    a) A base class value to a derived class reference
1059 	  //    b) An lvalue to an rvalue-reference of reference-compatible
1060 	  //       types that are not functions
1061 	  template<typename _Tp, typename _Arg>
1062 	    struct __is_direct_constructible_ref_cast
1063 	    : public __and_<__is_static_castable<_Arg, _Tp>,
1064 	                    __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
1065 	                                 __is_lvalue_to_rvalue_ref<_Arg, _Tp>
1066 	                   >>>
1067 	    { };
1068 	
1069 	  template<typename _Tp, typename _Arg>
1070 	    struct __is_direct_constructible_new
1071 	    : public conditional<is_reference<_Tp>::value,
1072 				 __is_direct_constructible_ref_cast<_Tp, _Arg>,
1073 				 __is_direct_constructible_new_safe<_Tp, _Arg>
1074 				 >::type
1075 	    { };
1076 	
1077 	  template<typename _Tp, typename _Arg>
1078 	    struct __is_direct_constructible
1079 	    : public __is_direct_constructible_new<_Tp, _Arg>::type
1080 	    { };
1081 	
1082 	  // Since default-construction and binary direct-initialization have
1083 	  // been handled separately, the implementation of the remaining
1084 	  // n-ary construction cases is rather straightforward. We can use
1085 	  // here a functional cast, because array types are excluded anyway
1086 	  // and this form is never interpreted as a C cast.
1087 	  struct __do_is_nary_constructible_impl
1088 	  {
1089 	    template<typename _Tp, typename... _Args, typename
1090 	             = decltype(_Tp(declval<_Args>()...))>
1091 	      static true_type __test(int);
1092 	
1093 	    template<typename, typename...>
1094 	      static false_type __test(...);
1095 	  };
1096 	
1097 	  template<typename _Tp, typename... _Args>
1098 	    struct __is_nary_constructible_impl
1099 	    : public __do_is_nary_constructible_impl
1100 	    {
1101 	      typedef decltype(__test<_Tp, _Args...>(0)) type;
1102 	    };
1103 	
1104 	  template<typename _Tp, typename... _Args>
1105 	    struct __is_nary_constructible
1106 	    : public __is_nary_constructible_impl<_Tp, _Args...>::type
1107 	    {
1108 	      static_assert(sizeof...(_Args) > 1,
1109 	                    "Only useful for > 1 arguments");
1110 	    };
1111 	
1112 	  template<typename _Tp, typename... _Args>
1113 	    struct __is_constructible_impl
1114 	    : public __is_nary_constructible<_Tp, _Args...>
1115 	    { };
1116 	
1117 	  template<typename _Tp, typename _Arg>
1118 	    struct __is_constructible_impl<_Tp, _Arg>
1119 	    : public __is_direct_constructible<_Tp, _Arg>
1120 	    { };
1121 	
1122 	  template<typename _Tp>
1123 	    struct __is_constructible_impl<_Tp>
1124 	    : public is_default_constructible<_Tp>
1125 	    { };
1126 	
1127 	  /// is_constructible
1128 	  template<typename _Tp, typename... _Args>
1129 	    struct is_constructible
1130 	    : public __is_constructible_impl<_Tp, _Args...>::type
1131 	    { };
1132 	
1133 	  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1134 	    struct __is_copy_constructible_impl;
1135 	
1136 	  template<typename _Tp>
1137 	    struct __is_copy_constructible_impl<_Tp, false>
1138 	    : public false_type { };
1139 	
1140 	  template<typename _Tp>
1141 	    struct __is_copy_constructible_impl<_Tp, true>
1142 	    : public is_constructible<_Tp, const _Tp&>
1143 	    { };
1144 	
1145 	  /// is_copy_constructible
1146 	  template<typename _Tp>
1147 	    struct is_copy_constructible
1148 	    : public __is_copy_constructible_impl<_Tp>
1149 	    { };
1150 	
1151 	  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1152 	    struct __is_move_constructible_impl;
1153 	
1154 	  template<typename _Tp>
1155 	    struct __is_move_constructible_impl<_Tp, false>
1156 	    : public false_type { };
1157 	
1158 	  template<typename _Tp>
1159 	    struct __is_move_constructible_impl<_Tp, true>
1160 	    : public is_constructible<_Tp, _Tp&&>
1161 	    { };
1162 	
1163 	  /// is_move_constructible
1164 	  template<typename _Tp>
1165 	    struct is_move_constructible
1166 	    : public __is_move_constructible_impl<_Tp>
1167 	    { };
1168 	
1169 	  template<typename _Tp>
1170 	    struct __is_nt_default_constructible_atom
1171 	    : public integral_constant<bool, noexcept(_Tp())>
1172 	    { };
1173 	
1174 	  template<typename _Tp, bool = is_array<_Tp>::value>
1175 	    struct __is_nt_default_constructible_impl;
1176 	
1177 	  template<typename _Tp>
1178 	    struct __is_nt_default_constructible_impl<_Tp, true>
1179 	    : public __and_<__is_array_known_bounds<_Tp>,
1180 			    __is_nt_default_constructible_atom<typename
1181 	                      remove_all_extents<_Tp>::type>>
1182 	    { };
1183 	
1184 	  template<typename _Tp>
1185 	    struct __is_nt_default_constructible_impl<_Tp, false>
1186 	    : public __is_nt_default_constructible_atom<_Tp>
1187 	    { };
1188 	
1189 	  /// is_nothrow_default_constructible
1190 	  template<typename _Tp>
1191 	    struct is_nothrow_default_constructible
1192 	    : public __and_<is_default_constructible<_Tp>,
1193 	                    __is_nt_default_constructible_impl<_Tp>>
1194 	    { };
1195 	
1196 	  template<typename _Tp, typename... _Args>
1197 	    struct __is_nt_constructible_impl
1198 	    : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
1199 	    { };
1200 	
1201 	  template<typename _Tp, typename _Arg>
1202 	    struct __is_nt_constructible_impl<_Tp, _Arg>
1203 	    : public integral_constant<bool,
1204 	                               noexcept(static_cast<_Tp>(declval<_Arg>()))>
1205 	    { };
1206 	
1207 	  template<typename _Tp>
1208 	    struct __is_nt_constructible_impl<_Tp>
1209 	    : public is_nothrow_default_constructible<_Tp>
1210 	    { };
1211 	
1212 	  /// is_nothrow_constructible
1213 	  template<typename _Tp, typename... _Args>
1214 	    struct is_nothrow_constructible
1215 	    : public __and_<is_constructible<_Tp, _Args...>,
1216 			    __is_nt_constructible_impl<_Tp, _Args...>>
1217 	    { };
1218 	
1219 	  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1220 	    struct __is_nothrow_copy_constructible_impl;
1221 	
1222 	  template<typename _Tp>
1223 	    struct __is_nothrow_copy_constructible_impl<_Tp, false>
1224 	    : public false_type { };
1225 	
1226 	  template<typename _Tp>
1227 	    struct __is_nothrow_copy_constructible_impl<_Tp, true>
1228 	    : public is_nothrow_constructible<_Tp, const _Tp&>
1229 	    { };
1230 	
1231 	  /// is_nothrow_copy_constructible
1232 	  template<typename _Tp>
1233 	    struct is_nothrow_copy_constructible
1234 	    : public __is_nothrow_copy_constructible_impl<_Tp>
1235 	    { };
1236 	
1237 	  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1238 	    struct __is_nothrow_move_constructible_impl;
1239 	
1240 	  template<typename _Tp>
1241 	    struct __is_nothrow_move_constructible_impl<_Tp, false>
1242 	    : public false_type { };
1243 	
1244 	  template<typename _Tp>
1245 	    struct __is_nothrow_move_constructible_impl<_Tp, true>
1246 	    : public is_nothrow_constructible<_Tp, _Tp&&>
1247 	    { };
1248 	
1249 	  /// is_nothrow_move_constructible
1250 	  template<typename _Tp>
1251 	    struct is_nothrow_move_constructible
1252 	    : public __is_nothrow_move_constructible_impl<_Tp>
1253 	    { };
1254 	
1255 	  template<typename _Tp, typename _Up>
1256 	    class __is_assignable_helper
1257 	    {
1258 	      template<typename _Tp1, typename _Up1,
1259 		       typename = decltype(declval<_Tp1>() = declval<_Up1>())>
1260 		static true_type
1261 		__test(int);
1262 	
1263 	      template<typename, typename>
1264 		static false_type
1265 		__test(...);
1266 	
1267 	    public:
1268 	      typedef decltype(__test<_Tp, _Up>(0)) type;
1269 	    };
1270 	
1271 	  /// is_assignable
1272 	  template<typename _Tp, typename _Up>
1273 	    struct is_assignable
1274 	      : public __is_assignable_helper<_Tp, _Up>::type
1275 	    { };
1276 	
1277 	  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1278 	    struct __is_copy_assignable_impl;
1279 	
1280 	  template<typename _Tp>
1281 	    struct __is_copy_assignable_impl<_Tp, false>
1282 	    : public false_type { };
1283 	
1284 	  template<typename _Tp>
1285 	    struct __is_copy_assignable_impl<_Tp, true>
1286 	    : public is_assignable<_Tp&, const _Tp&>
1287 	    { };
1288 	
1289 	  /// is_copy_assignable
1290 	  template<typename _Tp>
1291 	    struct is_copy_assignable
1292 	    : public __is_copy_assignable_impl<_Tp>
1293 	    { };
1294 	
1295 	  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1296 	    struct __is_move_assignable_impl;
1297 	
1298 	  template<typename _Tp>
1299 	    struct __is_move_assignable_impl<_Tp, false>
1300 	    : public false_type { };
1301 	
1302 	  template<typename _Tp>
1303 	    struct __is_move_assignable_impl<_Tp, true>
1304 	    : public is_assignable<_Tp&, _Tp&&>
1305 	    { };
1306 	
1307 	  /// is_move_assignable
1308 	  template<typename _Tp>
1309 	    struct is_move_assignable
1310 	    : public __is_move_assignable_impl<_Tp>
1311 	    { };
1312 	
1313 	  template<typename _Tp, typename _Up>
1314 	    struct __is_nt_assignable_impl
1315 	    : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
1316 	    { };
1317 	
1318 	  /// is_nothrow_assignable
1319 	  template<typename _Tp, typename _Up>
1320 	    struct is_nothrow_assignable
1321 	    : public __and_<is_assignable<_Tp, _Up>,
1322 			    __is_nt_assignable_impl<_Tp, _Up>>
1323 	    { };
1324 	
1325 	  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1326 	    struct __is_nt_copy_assignable_impl;
1327 	
1328 	  template<typename _Tp>
1329 	    struct __is_nt_copy_assignable_impl<_Tp, false>
1330 	    : public false_type { };
1331 	
1332 	  template<typename _Tp>
1333 	    struct __is_nt_copy_assignable_impl<_Tp, true>
1334 	    : public is_nothrow_assignable<_Tp&, const _Tp&>
1335 	    { };
1336 	
1337 	  /// is_nothrow_copy_assignable
1338 	  template<typename _Tp>
1339 	    struct is_nothrow_copy_assignable
1340 	    : public __is_nt_copy_assignable_impl<_Tp>
1341 	    { };
1342 	
1343 	  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1344 	    struct __is_nt_move_assignable_impl;
1345 	
1346 	  template<typename _Tp>
1347 	    struct __is_nt_move_assignable_impl<_Tp, false>
1348 	    : public false_type { };
1349 	
1350 	  template<typename _Tp>
1351 	    struct __is_nt_move_assignable_impl<_Tp, true>
1352 	    : public is_nothrow_assignable<_Tp&, _Tp&&>
1353 	    { };
1354 	
1355 	  /// is_nothrow_move_assignable
1356 	  template<typename _Tp>
1357 	    struct is_nothrow_move_assignable
1358 	    : public __is_nt_move_assignable_impl<_Tp>
1359 	    { };
1360 	
1361 	  /// is_trivially_constructible
1362 	  template<typename _Tp, typename... _Args>
1363 	    struct is_trivially_constructible
1364 	    : public __and_<is_constructible<_Tp, _Args...>, integral_constant<bool,
1365 				__is_trivially_constructible(_Tp, _Args...)>>
1366 	    { };
1367 	
1368 	  /// is_trivially_default_constructible
1369 	  template<typename _Tp>
1370 	    struct is_trivially_default_constructible
1371 	    : public is_trivially_constructible<_Tp>::type
1372 	    { };
1373 	
1374 	  struct __do_is_implicitly_default_constructible_impl
1375 	  {
1376 	    template <typename _Tp>
1377 	    static void __helper(const _Tp&);
1378 	
1379 	    template <typename _Tp>
1380 	    static true_type __test(const _Tp&,
1381 	                            decltype(__helper<const _Tp&>({}))* = 0);
1382 	
1383 	    static false_type __test(...);
1384 	  };
1385 	
1386 	  template<typename _Tp>
1387 	    struct __is_implicitly_default_constructible_impl
1388 	      : public __do_is_implicitly_default_constructible_impl
1389 	  {
1390 	    typedef decltype(__test(declval<_Tp>())) type;
1391 	  };
1392 	
1393 	  template<typename _Tp>
1394 	    struct __is_implicitly_default_constructible_safe
1395 	      : public __is_implicitly_default_constructible_impl<_Tp>::type
1396 	  { };
1397 	
1398 	  template <typename _Tp>
1399 	    struct __is_implicitly_default_constructible
1400 	      : public __and_<is_default_constructible<_Tp>,
1401 	                      __is_implicitly_default_constructible_safe<_Tp>>
1402 	  { };
1403 	
1404 	  /// is_trivially_copy_constructible
1405 	  template<typename _Tp>
1406 	    struct is_trivially_copy_constructible
1407 	    : public __and_<is_copy_constructible<_Tp>,
1408 			    integral_constant<bool,
1409 				__is_trivially_constructible(_Tp, const _Tp&)>>
1410 	    { };
1411 	
1412 	  /// is_trivially_move_constructible
1413 	  template<typename _Tp>
1414 	    struct is_trivially_move_constructible
1415 	    : public __and_<is_move_constructible<_Tp>,
1416 			    integral_constant<bool,
1417 				__is_trivially_constructible(_Tp, _Tp&&)>>
1418 	    { };
1419 	
1420 	  /// is_trivially_assignable
1421 	  template<typename _Tp, typename _Up>
1422 	    struct is_trivially_assignable
1423 	    : public __and_<is_assignable<_Tp, _Up>,
1424 			    integral_constant<bool,
1425 				__is_trivially_assignable(_Tp, _Up)>>
1426 	    { };
1427 	
1428 	  /// is_trivially_copy_assignable
1429 	  template<typename _Tp>
1430 	    struct is_trivially_copy_assignable
1431 	    : public __and_<is_copy_assignable<_Tp>,
1432 			    integral_constant<bool,
1433 				__is_trivially_assignable(_Tp&, const _Tp&)>>
1434 	    { };
1435 	
1436 	  /// is_trivially_move_assignable
1437 	  template<typename _Tp>
1438 	    struct is_trivially_move_assignable
1439 	    : public __and_<is_move_assignable<_Tp>,
1440 			    integral_constant<bool,
1441 				__is_trivially_assignable(_Tp&, _Tp&&)>>
1442 	    { };
1443 	
1444 	  /// is_trivially_destructible
1445 	  template<typename _Tp>
1446 	    struct is_trivially_destructible
1447 	    : public __and_<is_destructible<_Tp>, integral_constant<bool,
1448 				      __has_trivial_destructor(_Tp)>>
1449 	    { };
1450 	
1451 	
1452 	  /// has_virtual_destructor
1453 	  template<typename _Tp>
1454 	    struct has_virtual_destructor
1455 	    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
1456 	    { };
1457 	
1458 	
1459 	  // type property queries.
1460 	
1461 	  /// alignment_of
1462 	  template<typename _Tp>
1463 	    struct alignment_of
1464 	    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
1465 	
1466 	  /// rank
1467 	  template<typename>
1468 	    struct rank
1469 	    : public integral_constant<std::size_t, 0> { };
1470 	
1471 	  template<typename _Tp, std::size_t _Size>
1472 	    struct rank<_Tp[_Size]>
1473 	    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
1474 	
1475 	  template<typename _Tp>
1476 	    struct rank<_Tp[]>
1477 	    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
1478 	
1479 	  /// extent
1480 	  template<typename, unsigned _Uint>
1481 	    struct extent
1482 	    : public integral_constant<std::size_t, 0> { };
1483 	
1484 	  template<typename _Tp, unsigned _Uint, std::size_t _Size>
1485 	    struct extent<_Tp[_Size], _Uint>
1486 	    : public integral_constant<std::size_t,
1487 				       _Uint == 0 ? _Size : extent<_Tp,
1488 								   _Uint - 1>::value>
1489 	    { };
1490 	
1491 	  template<typename _Tp, unsigned _Uint>
1492 	    struct extent<_Tp[], _Uint>
1493 	    : public integral_constant<std::size_t,
1494 				       _Uint == 0 ? 0 : extent<_Tp,
1495 							       _Uint - 1>::value>
1496 	    { };
1497 	
1498 	
1499 	  // Type relations.
1500 	
1501 	  /// is_same
1502 	  template<typename, typename>
1503 	    struct is_same
1504 	    : public false_type { };
1505 	
1506 	  template<typename _Tp>
1507 	    struct is_same<_Tp, _Tp>
1508 	    : public true_type { };
1509 	
1510 	  /// is_base_of
1511 	  template<typename _Base, typename _Derived>
1512 	    struct is_base_of
1513 	    : public integral_constant<bool, __is_base_of(_Base, _Derived)>
1514 	    { };
1515 	
1516 	  template<typename _From, typename _To,
1517 	           bool = __or_<is_void<_From>, is_function<_To>,
1518 	                        is_array<_To>>::value>
1519 	    struct __is_convertible_helper
1520 	    { typedef typename is_void<_To>::type type; };
1521 	
1522 	  template<typename _From, typename _To>
1523 	    class __is_convertible_helper<_From, _To, false>
1524 	    {
1525 	       template<typename _To1>
1526 		static void __test_aux(_To1);
1527 	
1528 	      template<typename _From1, typename _To1,
1529 		       typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
1530 		static true_type
1531 		__test(int);
1532 	
1533 	      template<typename, typename>
1534 		static false_type
1535 		__test(...);
1536 	
1537 	    public:
1538 	      typedef decltype(__test<_From, _To>(0)) type;
1539 	    };
1540 	
1541 	
1542 	  /// is_convertible
1543 	  template<typename _From, typename _To>
1544 	    struct is_convertible
1545 	    : public __is_convertible_helper<_From, _To>::type
1546 	    { };
1547 	
1548 	
1549 	  // Const-volatile modifications.
1550 	
1551 	  /// remove_const
1552 	  template<typename _Tp>
1553 	    struct remove_const
1554 	    { typedef _Tp     type; };
1555 	
1556 	  template<typename _Tp>
1557 	    struct remove_const<_Tp const>
1558 	    { typedef _Tp     type; };
1559 	
1560 	  /// remove_volatile
1561 	  template<typename _Tp>
1562 	    struct remove_volatile
1563 	    { typedef _Tp     type; };
1564 	
1565 	  template<typename _Tp>
1566 	    struct remove_volatile<_Tp volatile>
1567 	    { typedef _Tp     type; };
1568 	
1569 	  /// remove_cv
1570 	  template<typename _Tp>
1571 	    struct remove_cv
1572 	    {
1573 	      typedef typename
1574 	      remove_const<typename remove_volatile<_Tp>::type>::type     type;
1575 	    };
1576 	
1577 	  /// add_const
1578 	  template<typename _Tp>
1579 	    struct add_const
1580 	    { typedef _Tp const     type; };
1581 	
1582 	  /// add_volatile
1583 	  template<typename _Tp>
1584 	    struct add_volatile
1585 	    { typedef _Tp volatile     type; };
1586 	
1587 	  /// add_cv
1588 	  template<typename _Tp>
1589 	    struct add_cv
1590 	    {
1591 	      typedef typename
1592 	      add_const<typename add_volatile<_Tp>::type>::type     type;
1593 	    };
1594 	
1595 	#if __cplusplus > 201103L
1596 	
1597 	#define __cpp_lib_transformation_trait_aliases 201304
1598 	
1599 	  /// Alias template for remove_const
1600 	  template<typename _Tp>
1601 	    using remove_const_t = typename remove_const<_Tp>::type;
1602 	
1603 	  /// Alias template for remove_volatile
1604 	  template<typename _Tp>
1605 	    using remove_volatile_t = typename remove_volatile<_Tp>::type;
1606 	
1607 	  /// Alias template for remove_cv
1608 	  template<typename _Tp>
1609 	    using remove_cv_t = typename remove_cv<_Tp>::type;
1610 	
1611 	  /// Alias template for add_const
1612 	  template<typename _Tp>
1613 	    using add_const_t = typename add_const<_Tp>::type;
1614 	
1615 	  /// Alias template for add_volatile
1616 	  template<typename _Tp>
1617 	    using add_volatile_t = typename add_volatile<_Tp>::type;
1618 	
1619 	  /// Alias template for add_cv
1620 	  template<typename _Tp>
1621 	    using add_cv_t = typename add_cv<_Tp>::type;
1622 	#endif
1623 	
1624 	  // Reference transformations.
1625 	
1626 	  /// remove_reference
1627 	  template<typename _Tp>
1628 	    struct remove_reference
1629 	    { typedef _Tp   type; };
1630 	
1631 	  template<typename _Tp>
1632 	    struct remove_reference<_Tp&>
1633 	    { typedef _Tp   type; };
1634 	
1635 	  template<typename _Tp>
1636 	    struct remove_reference<_Tp&&>
1637 	    { typedef _Tp   type; };
1638 	
1639 	  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1640 	    struct __add_lvalue_reference_helper
1641 	    { typedef _Tp   type; };
1642 	
1643 	  template<typename _Tp>
1644 	    struct __add_lvalue_reference_helper<_Tp, true>
1645 	    { typedef _Tp&   type; };
1646 	
1647 	  /// add_lvalue_reference
1648 	  template<typename _Tp>
1649 	    struct add_lvalue_reference
1650 	    : public __add_lvalue_reference_helper<_Tp>
1651 	    { };
1652 	
1653 	  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1654 	    struct __add_rvalue_reference_helper
1655 	    { typedef _Tp   type; };
1656 	
1657 	  template<typename _Tp>
1658 	    struct __add_rvalue_reference_helper<_Tp, true>
1659 	    { typedef _Tp&&   type; };
1660 	
1661 	  /// add_rvalue_reference
1662 	  template<typename _Tp>
1663 	    struct add_rvalue_reference
1664 	    : public __add_rvalue_reference_helper<_Tp>
1665 	    { };
1666 	
1667 	#if __cplusplus > 201103L
1668 	  /// Alias template for remove_reference
1669 	  template<typename _Tp>
1670 	    using remove_reference_t = typename remove_reference<_Tp>::type;
1671 	
1672 	  /// Alias template for add_lvalue_reference
1673 	  template<typename _Tp>
1674 	    using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
1675 	
1676 	  /// Alias template for add_rvalue_reference
1677 	  template<typename _Tp>
1678 	    using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
1679 	#endif
1680 	
1681 	  // Sign modifications.
1682 	
1683 	  // Utility for constructing identically cv-qualified types.
1684 	  template<typename _Unqualified, bool _IsConst, bool _IsVol>
1685 	    struct __cv_selector;
1686 	
1687 	  template<typename _Unqualified>
1688 	    struct __cv_selector<_Unqualified, false, false>
1689 	    { typedef _Unqualified __type; };
1690 	
1691 	  template<typename _Unqualified>
1692 	    struct __cv_selector<_Unqualified, false, true>
1693 	    { typedef volatile _Unqualified __type; };
1694 	
1695 	  template<typename _Unqualified>
1696 	    struct __cv_selector<_Unqualified, true, false>
1697 	    { typedef const _Unqualified __type; };
1698 	
1699 	  template<typename _Unqualified>
1700 	    struct __cv_selector<_Unqualified, true, true>
1701 	    { typedef const volatile _Unqualified __type; };
1702 	
1703 	  template<typename _Qualified, typename _Unqualified,
1704 		   bool _IsConst = is_const<_Qualified>::value,
1705 		   bool _IsVol = is_volatile<_Qualified>::value>
1706 	    class __match_cv_qualifiers
1707 	    {
1708 	      typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
1709 	
1710 	    public:
1711 	      typedef typename __match::__type __type;
1712 	    };
1713 	
1714 	  // Utility for finding the unsigned versions of signed integral types.
1715 	  template<typename _Tp>
1716 	    struct __make_unsigned
1717 	    { typedef _Tp __type; };
1718 	
1719 	  template<>
1720 	    struct __make_unsigned<char>
1721 	    { typedef unsigned char __type; };
1722 	
1723 	  template<>
1724 	    struct __make_unsigned<signed char>
1725 	    { typedef unsigned char __type; };
1726 	
1727 	  template<>
1728 	    struct __make_unsigned<short>
1729 	    { typedef unsigned short __type; };
1730 	
1731 	  template<>
1732 	    struct __make_unsigned<int>
1733 	    { typedef unsigned int __type; };
1734 	
1735 	  template<>
1736 	    struct __make_unsigned<long>
1737 	    { typedef unsigned long __type; };
1738 	
1739 	  template<>
1740 	    struct __make_unsigned<long long>
1741 	    { typedef unsigned long long __type; };
1742 	
1743 	#if defined(_GLIBCXX_USE_WCHAR_T) && !defined(__WCHAR_UNSIGNED__)
1744 	  template<>
1745 	    struct __make_unsigned<wchar_t> : __make_unsigned<__WCHAR_TYPE__>
1746 	    { };
1747 	#endif
1748 	
1749 	#if defined(__GLIBCXX_TYPE_INT_N_0)
1750 	  template<>
1751 	    struct __make_unsigned<__GLIBCXX_TYPE_INT_N_0>
1752 	    { typedef unsigned __GLIBCXX_TYPE_INT_N_0 __type; };
1753 	#endif
1754 	#if defined(__GLIBCXX_TYPE_INT_N_1)
1755 	  template<>
1756 	    struct __make_unsigned<__GLIBCXX_TYPE_INT_N_1>
1757 	    { typedef unsigned __GLIBCXX_TYPE_INT_N_1 __type; };
1758 	#endif
1759 	#if defined(__GLIBCXX_TYPE_INT_N_2)
1760 	  template<>
1761 	    struct __make_unsigned<__GLIBCXX_TYPE_INT_N_2>
1762 	    { typedef unsigned __GLIBCXX_TYPE_INT_N_2 __type; };
1763 	#endif
1764 	#if defined(__GLIBCXX_TYPE_INT_N_3)
1765 	  template<>
1766 	    struct __make_unsigned<__GLIBCXX_TYPE_INT_N_3>
1767 	    { typedef unsigned __GLIBCXX_TYPE_INT_N_3 __type; };
1768 	#endif
1769 	
1770 	  // Select between integral and enum: not possible to be both.
1771 	  template<typename _Tp,
1772 		   bool _IsInt = is_integral<_Tp>::value,
1773 		   bool _IsEnum = is_enum<_Tp>::value>
1774 	    class __make_unsigned_selector;
1775 	
1776 	  template<typename _Tp>
1777 	    class __make_unsigned_selector<_Tp, true, false>
1778 	    {
1779 	      typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
1780 	      typedef typename __unsignedt::__type __unsigned_type;
1781 	      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
1782 	
1783 	    public:
1784 	      typedef typename __cv_unsigned::__type __type;
1785 	    };
1786 	
1787 	  template<typename _Tp>
1788 	    class __make_unsigned_selector<_Tp, false, true>
1789 	    {
1790 	      // With -fshort-enums, an enum may be as small as a char.
1791 	      typedef unsigned char __smallest;
1792 	      static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
1793 	      static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
1794 	      static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
1795 	      static const bool __b3 = sizeof(_Tp) <= sizeof(unsigned long);
1796 	      typedef conditional<__b3, unsigned long, unsigned long long> __cond3;
1797 	      typedef typename __cond3::type __cond3_type;
1798 	      typedef conditional<__b2, unsigned int, __cond3_type> __cond2;
1799 	      typedef typename __cond2::type __cond2_type;
1800 	      typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
1801 	      typedef typename __cond1::type __cond1_type;
1802 	
1803 	      typedef typename conditional<__b0, __smallest, __cond1_type>::type
1804 		__unsigned_type;
1805 	      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
1806 	
1807 	    public:
1808 	      typedef typename __cv_unsigned::__type __type;
1809 	    };
1810 	
1811 	  // Given an integral/enum type, return the corresponding unsigned
1812 	  // integer type.
1813 	  // Primary template.
1814 	  /// make_unsigned
1815 	  template<typename _Tp>
1816 	    struct make_unsigned
1817 	    { typedef typename __make_unsigned_selector<_Tp>::__type type; };
1818 	
1819 	  // Integral, but don't define.
1820 	  template<>
1821 	    struct make_unsigned<bool>;
1822 	
1823 	
1824 	  // Utility for finding the signed versions of unsigned integral types.
1825 	  template<typename _Tp>
1826 	    struct __make_signed
1827 	    { typedef _Tp __type; };
1828 	
1829 	  template<>
1830 	    struct __make_signed<char>
1831 	    { typedef signed char __type; };
1832 	
1833 	  template<>
1834 	    struct __make_signed<unsigned char>
1835 	    { typedef signed char __type; };
1836 	
1837 	  template<>
1838 	    struct __make_signed<unsigned short>
1839 	    { typedef signed short __type; };
1840 	
1841 	  template<>
1842 	    struct __make_signed<unsigned int>
1843 	    { typedef signed int __type; };
1844 	
1845 	  template<>
1846 	    struct __make_signed<unsigned long>
1847 	    { typedef signed long __type; };
1848 	
1849 	  template<>
1850 	    struct __make_signed<unsigned long long>
1851 	    { typedef signed long long __type; };
1852 	
1853 	#if defined(_GLIBCXX_USE_WCHAR_T) && defined(__WCHAR_UNSIGNED__)
1854 	  template<>
1855 	    struct __make_signed<wchar_t> : __make_signed<__WCHAR_TYPE__>
1856 	    { };
1857 	#endif
1858 	
1859 	#ifdef _GLIBCXX_USE_C99_STDINT_TR1
1860 	  template<>
1861 	    struct __make_signed<char16_t> : __make_signed<uint_least16_t>
1862 	    { };
1863 	  template<>
1864 	    struct __make_signed<char32_t> : __make_signed<uint_least32_t>
1865 	    { };
1866 	#endif
1867 	
1868 	#if defined(__GLIBCXX_TYPE_INT_N_0)
1869 	  template<>
1870 	    struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_0>
1871 	    { typedef __GLIBCXX_TYPE_INT_N_0 __type; };
1872 	#endif
1873 	#if defined(__GLIBCXX_TYPE_INT_N_1)
1874 	  template<>
1875 	    struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_1>
1876 	    { typedef __GLIBCXX_TYPE_INT_N_1 __type; };
1877 	#endif
1878 	#if defined(__GLIBCXX_TYPE_INT_N_2)
1879 	  template<>
1880 	    struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_2>
1881 	    { typedef __GLIBCXX_TYPE_INT_N_2 __type; };
1882 	#endif
1883 	#if defined(__GLIBCXX_TYPE_INT_N_3)
1884 	  template<>
1885 	    struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_3>
1886 	    { typedef __GLIBCXX_TYPE_INT_N_3 __type; };
1887 	#endif
1888 	
1889 	  // Select between integral and enum: not possible to be both.
1890 	  template<typename _Tp,
1891 		   bool _IsInt = is_integral<_Tp>::value,
1892 		   bool _IsEnum = is_enum<_Tp>::value>
1893 	    class __make_signed_selector;
1894 	
1895 	  template<typename _Tp>
1896 	    class __make_signed_selector<_Tp, true, false>
1897 	    {
1898 	      typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
1899 	      typedef typename __signedt::__type __signed_type;
1900 	      typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
1901 	
1902 	    public:
1903 	      typedef typename __cv_signed::__type __type;
1904 	    };
1905 	
1906 	  template<typename _Tp>
1907 	    class __make_signed_selector<_Tp, false, true>
1908 	    {
1909 	      typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
1910 	
1911 	    public:
1912 	      typedef typename __make_signed_selector<__unsigned_type>::__type __type;
1913 	    };
1914 	
1915 	  // Given an integral/enum type, return the corresponding signed
1916 	  // integer type.
1917 	  // Primary template.
1918 	  /// make_signed
1919 	  template<typename _Tp>
1920 	    struct make_signed
1921 	    { typedef typename __make_signed_selector<_Tp>::__type type; };
1922 	
1923 	  // Integral, but don't define.
1924 	  template<>
1925 	    struct make_signed<bool>;
1926 	
1927 	#if __cplusplus > 201103L
1928 	  /// Alias template for make_signed
1929 	  template<typename _Tp>
1930 	    using make_signed_t = typename make_signed<_Tp>::type;
1931 	
1932 	  /// Alias template for make_unsigned
1933 	  template<typename _Tp>
1934 	    using make_unsigned_t = typename make_unsigned<_Tp>::type;
1935 	#endif
1936 	
1937 	  // Array modifications.
1938 	
1939 	  /// remove_extent
1940 	  template<typename _Tp>
1941 	    struct remove_extent
1942 	    { typedef _Tp     type; };
1943 	
1944 	  template<typename _Tp, std::size_t _Size>
1945 	    struct remove_extent<_Tp[_Size]>
1946 	    { typedef _Tp     type; };
1947 	
1948 	  template<typename _Tp>
1949 	    struct remove_extent<_Tp[]>
1950 	    { typedef _Tp     type; };
1951 	
1952 	  /// remove_all_extents
1953 	  template<typename _Tp>
1954 	    struct remove_all_extents
1955 	    { typedef _Tp     type; };
1956 	
1957 	  template<typename _Tp, std::size_t _Size>
1958 	    struct remove_all_extents<_Tp[_Size]>
1959 	    { typedef typename remove_all_extents<_Tp>::type     type; };
1960 	
1961 	  template<typename _Tp>
1962 	    struct remove_all_extents<_Tp[]>
1963 	    { typedef typename remove_all_extents<_Tp>::type     type; };
1964 	
1965 	#if __cplusplus > 201103L
1966 	  /// Alias template for remove_extent
1967 	  template<typename _Tp>
1968 	    using remove_extent_t = typename remove_extent<_Tp>::type;
1969 	
1970 	  /// Alias template for remove_all_extents
1971 	  template<typename _Tp>
1972 	    using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
1973 	#endif
1974 	
1975 	  // Pointer modifications.
1976 	
1977 	  template<typename _Tp, typename>
1978 	    struct __remove_pointer_helper
1979 	    { typedef _Tp     type; };
1980 	
1981 	  template<typename _Tp, typename _Up>
1982 	    struct __remove_pointer_helper<_Tp, _Up*>
1983 	    { typedef _Up     type; };
1984 	
1985 	  /// remove_pointer
1986 	  template<typename _Tp>
1987 	    struct remove_pointer
1988 	    : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
1989 	    { };
1990 	
1991 	  /// add_pointer
1992 	  template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
1993 					      is_void<_Tp>>::value>
1994 	    struct __add_pointer_helper
1995 	    { typedef _Tp     type; };
1996 	
1997 	  template<typename _Tp>
1998 	    struct __add_pointer_helper<_Tp, true>
1999 	    { typedef typename remove_reference<_Tp>::type*     type; };
2000 	
2001 	  template<typename _Tp>
2002 	    struct add_pointer
2003 	    : public __add_pointer_helper<_Tp>
2004 	    { };
2005 	
2006 	#if __cplusplus > 201103L
2007 	  /// Alias template for remove_pointer
2008 	  template<typename _Tp>
2009 	    using remove_pointer_t = typename remove_pointer<_Tp>::type;
2010 	
2011 	  /// Alias template for add_pointer
2012 	  template<typename _Tp>
2013 	    using add_pointer_t = typename add_pointer<_Tp>::type;
2014 	#endif
2015 	
2016 	  template<std::size_t _Len>
2017 	    struct __aligned_storage_msa
2018 	    {
2019 	      union __type
2020 	      {
2021 		unsigned char __data[_Len];
2022 		struct __attribute__((__aligned__)) { } __align;
2023 	      };
2024 	    };
2025 	
2026 	  /**
2027 	   *  @brief Alignment type.
2028 	   *
2029 	   *  The value of _Align is a default-alignment which shall be the
2030 	   *  most stringent alignment requirement for any C++ object type
2031 	   *  whose size is no greater than _Len (3.9). The member typedef
2032 	   *  type shall be a POD type suitable for use as uninitialized
2033 	   *  storage for any object whose size is at most _Len and whose
2034 	   *  alignment is a divisor of _Align.
2035 	  */
2036 	  template<std::size_t _Len, std::size_t _Align =
2037 		   __alignof__(typename __aligned_storage_msa<_Len>::__type)>
2038 	    struct aligned_storage
2039 	    {
2040 	      union type
2041 	      {
2042 		unsigned char __data[_Len];
2043 		struct __attribute__((__aligned__((_Align)))) { } __align;
2044 	      };
2045 	    };
2046 	
2047 	  template <typename... _Types>
2048 	    struct __strictest_alignment
2049 	    {
2050 	      static const size_t _S_alignment = 0;
2051 	      static const size_t _S_size = 0;
2052 	    };
2053 	
2054 	  template <typename _Tp, typename... _Types>
2055 	    struct __strictest_alignment<_Tp, _Types...>
2056 	    {
2057 	      static const size_t _S_alignment =
2058 	        alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
2059 		? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
2060 	      static const size_t _S_size =
2061 	        sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
2062 		? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
2063 	    };
2064 	
2065 	  /**
2066 	   *  @brief Provide aligned storage for types.
2067 	   *
2068 	   *  [meta.trans.other]
2069 	   *
2070 	   *  Provides aligned storage for any of the provided types of at
2071 	   *  least size _Len.
2072 	   *
2073 	   *  @see aligned_storage
2074 	   */
2075 	  template <size_t _Len, typename... _Types>
2076 	    struct aligned_union
2077 	    {
2078 	    private:
2079 	      static_assert(sizeof...(_Types) != 0, "At least one type is required");
2080 	
2081 	      using __strictest = __strictest_alignment<_Types...>;
2082 	      static const size_t _S_len = _Len > __strictest::_S_size
2083 		? _Len : __strictest::_S_size;
2084 	    public:
2085 	      /// The value of the strictest alignment of _Types.
2086 	      static const size_t alignment_value = __strictest::_S_alignment;
2087 	      /// The storage.
2088 	      typedef typename aligned_storage<_S_len, alignment_value>::type type;
2089 	    };
2090 	
2091 	  template <size_t _Len, typename... _Types>
2092 	    const size_t aligned_union<_Len, _Types...>::alignment_value;
2093 	
2094 	  // Decay trait for arrays and functions, used for perfect forwarding
2095 	  // in make_pair, make_tuple, etc.
2096 	  template<typename _Up,
2097 		   bool _IsArray = is_array<_Up>::value,
2098 		   bool _IsFunction = is_function<_Up>::value>
2099 	    struct __decay_selector;
2100 	
2101 	  // NB: DR 705.
2102 	  template<typename _Up>
2103 	    struct __decay_selector<_Up, false, false>
2104 	    { typedef typename remove_cv<_Up>::type __type; };
2105 	
2106 	  template<typename _Up>
2107 	    struct __decay_selector<_Up, true, false>
2108 	    { typedef typename remove_extent<_Up>::type* __type; };
2109 	
2110 	  template<typename _Up>
2111 	    struct __decay_selector<_Up, false, true>
2112 	    { typedef typename add_pointer<_Up>::type __type; };
2113 	
2114 	  /// decay
2115 	  template<typename _Tp>
2116 	    class decay
2117 	    {
2118 	      typedef typename remove_reference<_Tp>::type __remove_type;
2119 	
2120 	    public:
2121 	      typedef typename __decay_selector<__remove_type>::__type type;
2122 	    };
2123 	
2124 	  template<typename _Tp>
2125 	    class reference_wrapper;
2126 	
2127 	  // Helper which adds a reference to a type when given a reference_wrapper
2128 	  template<typename _Tp>
2129 	    struct __strip_reference_wrapper
2130 	    {
2131 	      typedef _Tp __type;
2132 	    };
2133 	
2134 	  template<typename _Tp>
2135 	    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
2136 	    {
2137 	      typedef _Tp& __type;
2138 	    };
2139 	
2140 	  template<typename _Tp>
2141 	    struct __decay_and_strip
2142 	    {
2143 	      typedef typename __strip_reference_wrapper<
2144 		typename decay<_Tp>::type>::__type __type;
2145 	    };
2146 	
2147 	
2148 	  // Primary template.
2149 	  /// Define a member typedef @c type only if a boolean constant is true.
2150 	  template<bool, typename _Tp = void>
2151 	    struct enable_if
2152 	    { };
2153 	
2154 	  // Partial specialization for true.
2155 	  template<typename _Tp>
2156 	    struct enable_if<true, _Tp>
2157 	    { typedef _Tp type; };
2158 	
2159 	  template<typename... _Cond>
2160 	    using _Require = typename enable_if<__and_<_Cond...>::value>::type;
2161 	
2162 	  // Primary template.
2163 	  /// Define a member typedef @c type to one of two argument types.
2164 	  template<bool _Cond, typename _Iftrue, typename _Iffalse>
2165 	    struct conditional
2166 	    { typedef _Iftrue type; };
2167 	
2168 	  // Partial specialization for false.
2169 	  template<typename _Iftrue, typename _Iffalse>
2170 	    struct conditional<false, _Iftrue, _Iffalse>
2171 	    { typedef _Iffalse type; };
2172 	
2173 	  /// common_type
2174 	  template<typename... _Tp>
2175 	    struct common_type;
2176 	
2177 	  // Sfinae-friendly common_type implementation:
2178 	
2179 	  struct __do_common_type_impl
2180 	  {
2181 	    template<typename _Tp, typename _Up>
2182 	      static __success_type<typename decay<decltype
2183 				    (true ? std::declval<_Tp>()
2184 				     : std::declval<_Up>())>::type> _S_test(int);
2185 	
2186 	    template<typename, typename>
2187 	      static __failure_type _S_test(...);
2188 	  };
2189 	
2190 	  template<typename _Tp, typename _Up>
2191 	    struct __common_type_impl
2192 	    : private __do_common_type_impl
2193 	    {
2194 	      typedef decltype(_S_test<_Tp, _Up>(0)) type;
2195 	    };
2196 	
2197 	  struct __do_member_type_wrapper
2198 	  {
2199 	    template<typename _Tp>
2200 	      static __success_type<typename _Tp::type> _S_test(int);
2201 	
2202 	    template<typename>
2203 	      static __failure_type _S_test(...);
2204 	  };
2205 	
2206 	  template<typename _Tp>
2207 	    struct __member_type_wrapper
2208 	    : private __do_member_type_wrapper
2209 	    {
2210 	      typedef decltype(_S_test<_Tp>(0)) type;
2211 	    };
2212 	
2213 	  template<typename _CTp, typename... _Args>
2214 	    struct __expanded_common_type_wrapper
2215 	    {
2216 	      typedef common_type<typename _CTp::type, _Args...> type;
2217 	    };
2218 	
2219 	  template<typename... _Args>
2220 	    struct __expanded_common_type_wrapper<__failure_type, _Args...>
2221 	    { typedef __failure_type type; };
2222 	
2223 	  template<typename _Tp>
2224 	    struct common_type<_Tp>
2225 	    { typedef typename decay<_Tp>::type type; };
2226 	
2227 	  template<typename _Tp, typename _Up>
2228 	    struct common_type<_Tp, _Up>
2229 	    : public __common_type_impl<_Tp, _Up>::type
2230 	    { };
2231 	
2232 	  template<typename _Tp, typename _Up, typename... _Vp>
2233 	    struct common_type<_Tp, _Up, _Vp...>
2234 	    : public __expanded_common_type_wrapper<typename __member_type_wrapper<
2235 	               common_type<_Tp, _Up>>::type, _Vp...>::type
2236 	    { };
2237 	
2238 	  /// The underlying type of an enum.
2239 	  template<typename _Tp>
2240 	    struct underlying_type
2241 	    {
2242 	      typedef __underlying_type(_Tp) type;
2243 	    };
2244 	
2245 	  template<typename _Tp>
2246 	    struct __declval_protector
2247 	    {
2248 	      static const bool __stop = false;
2249 	      static typename add_rvalue_reference<_Tp>::type __delegate();
2250 	    };
2251 	
2252 	  template<typename _Tp>
2253 	    inline typename add_rvalue_reference<_Tp>::type
2254 	    declval() noexcept
2255 	    {
2256 	      static_assert(__declval_protector<_Tp>::__stop,
2257 			    "declval() must not be used!");
2258 	      return __declval_protector<_Tp>::__delegate();
2259 	    }
2260 	
2261 	  /// result_of
2262 	  template<typename _Signature>
2263 	    class result_of;
2264 	
2265 	  // Sfinae-friendly result_of implementation:
2266 	
2267 	#define __cpp_lib_result_of_sfinae 201210
2268 	
2269 	  struct __invoke_memfun_ref { };
2270 	  struct __invoke_memfun_deref { };
2271 	  struct __invoke_memobj_ref { };
2272 	  struct __invoke_memobj_deref { };
2273 	  struct __invoke_other { };
2274 	
2275 	  // Associate a tag type with a specialization of __success_type.
2276 	  template<typename _Tp, typename _Tag>
2277 	    struct __result_of_success : __success_type<_Tp>
2278 	    { using __invoke_type = _Tag; };
2279 	
2280 	  // [func.require] paragraph 1 bullet 1:
2281 	  struct __result_of_memfun_ref_impl
2282 	  {
2283 	    template<typename _Fp, typename _Tp1, typename... _Args>
2284 	      static __result_of_success<decltype(
2285 	      (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
2286 	      ), __invoke_memfun_ref> _S_test(int);
2287 	
2288 	    template<typename...>
2289 	      static __failure_type _S_test(...);
2290 	  };
2291 	
2292 	  template<typename _MemPtr, typename _Arg, typename... _Args>
2293 	    struct __result_of_memfun_ref
2294 	    : private __result_of_memfun_ref_impl
2295 	    {
2296 	      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2297 	    };
2298 	
2299 	  // [func.require] paragraph 1 bullet 2:
2300 	  struct __result_of_memfun_deref_impl
2301 	  {
2302 	    template<typename _Fp, typename _Tp1, typename... _Args>
2303 	      static __result_of_success<decltype(
2304 	      ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
2305 	      ), __invoke_memfun_deref> _S_test(int);
2306 	
2307 	    template<typename...>
2308 	      static __failure_type _S_test(...);
2309 	  };
2310 	
2311 	  template<typename _MemPtr, typename _Arg, typename... _Args>
2312 	    struct __result_of_memfun_deref
2313 	    : private __result_of_memfun_deref_impl
2314 	    {
2315 	      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2316 	    };
2317 	
2318 	  // [func.require] paragraph 1 bullet 3:
2319 	  struct __result_of_memobj_ref_impl
2320 	  {
2321 	    template<typename _Fp, typename _Tp1>
2322 	      static __result_of_success<decltype(
2323 	      std::declval<_Tp1>().*std::declval<_Fp>()
2324 	      ), __invoke_memobj_ref> _S_test(int);
2325 	
2326 	    template<typename, typename>
2327 	      static __failure_type _S_test(...);
2328 	  };
2329 	
2330 	  template<typename _MemPtr, typename _Arg>
2331 	    struct __result_of_memobj_ref
2332 	    : private __result_of_memobj_ref_impl
2333 	    {
2334 	      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
2335 	    };
2336 	
2337 	  // [func.require] paragraph 1 bullet 4:
2338 	  struct __result_of_memobj_deref_impl
2339 	  {
2340 	    template<typename _Fp, typename _Tp1>
2341 	      static __result_of_success<decltype(
2342 	      (*std::declval<_Tp1>()).*std::declval<_Fp>()
2343 	      ), __invoke_memobj_deref> _S_test(int);
2344 	
2345 	    template<typename, typename>
2346 	      static __failure_type _S_test(...);
2347 	  };
2348 	
2349 	  template<typename _MemPtr, typename _Arg>
2350 	    struct __result_of_memobj_deref
2351 	    : private __result_of_memobj_deref_impl
2352 	    {
2353 	      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
2354 	    };
2355 	
2356 	  template<typename _MemPtr, typename _Arg>
2357 	    struct __result_of_memobj;
2358 	
2359 	  template<typename _Res, typename _Class, typename _Arg>
2360 	    struct __result_of_memobj<_Res _Class::*, _Arg>
2361 	    {
2362 	      typedef typename remove_cv<typename remove_reference<
2363 	        _Arg>::type>::type _Argval;
2364 	      typedef _Res _Class::* _MemPtr;
2365 	      typedef typename conditional<__or_<is_same<_Argval, _Class>,
2366 	        is_base_of<_Class, _Argval>>::value,
2367 	        __result_of_memobj_ref<_MemPtr, _Arg>,
2368 	        __result_of_memobj_deref<_MemPtr, _Arg>
2369 	      >::type::type type;
2370 	    };
2371 	
2372 	  template<typename _MemPtr, typename _Arg, typename... _Args>
2373 	    struct __result_of_memfun;
2374 	
2375 	  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
2376 	    struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
2377 	    {
2378 	      typedef typename remove_cv<typename remove_reference<
2379 	        _Arg>::type>::type _Argval;
2380 	      typedef _Res _Class::* _MemPtr;
2381 	      typedef typename conditional<__or_<is_same<_Argval, _Class>,
2382 	        is_base_of<_Class, _Argval>>::value,
2383 	        __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
2384 	        __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
2385 	      >::type::type type;
2386 	    };
2387 	
2388 	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
2389 	  // 2219.  INVOKE-ing a pointer to member with a reference_wrapper
2390 	  //        as the object expression
2391 	
2392 	  // Used by result_of, invoke etc. to unwrap a reference_wrapper.
2393 	  template<typename _Tp, typename _Up = typename decay<_Tp>::type>
2394 	    struct __inv_unwrap
2395 	    {
2396 	      using type = _Tp;
2397 	    };
2398 	
2399 	  template<typename _Tp, typename _Up>
2400 	    struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
2401 	    {
2402 	      using type = _Up&;
2403 	    };
2404 	
2405 	  template<bool, bool, typename _Functor, typename... _ArgTypes>
2406 	    struct __result_of_impl
2407 	    {
2408 	      typedef __failure_type type;
2409 	    };
2410 	
2411 	  template<typename _MemPtr, typename _Arg>
2412 	    struct __result_of_impl<true, false, _MemPtr, _Arg>
2413 	    : public __result_of_memobj<typename decay<_MemPtr>::type,
2414 					typename __inv_unwrap<_Arg>::type>
2415 	    { };
2416 	
2417 	  template<typename _MemPtr, typename _Arg, typename... _Args>
2418 	    struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
2419 	    : public __result_of_memfun<typename decay<_MemPtr>::type,
2420 					typename __inv_unwrap<_Arg>::type, _Args...>
2421 	    { };
2422 	
2423 	  // [func.require] paragraph 1 bullet 5:
2424 	  struct __result_of_other_impl
2425 	  {
2426 	    template<typename _Fn, typename... _Args>
2427 	      static __result_of_success<decltype(
2428 	      std::declval<_Fn>()(std::declval<_Args>()...)
2429 	      ), __invoke_other> _S_test(int);
2430 	
2431 	    template<typename...>
2432 	      static __failure_type _S_test(...);
2433 	  };
2434 	
2435 	  template<typename _Functor, typename... _ArgTypes>
2436 	    struct __result_of_impl<false, false, _Functor, _ArgTypes...>
2437 	    : private __result_of_other_impl
2438 	    {
2439 	      typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
2440 	    };
2441 	
2442 	  // __invoke_result (std::invoke_result for C++11)
2443 	  template<typename _Functor, typename... _ArgTypes>
2444 	    struct __invoke_result
2445 	    : public __result_of_impl<
2446 	        is_member_object_pointer<
2447 	          typename remove_reference<_Functor>::type
2448 	        >::value,
2449 	        is_member_function_pointer<
2450 	          typename remove_reference<_Functor>::type
2451 	        >::value,
2452 		_Functor, _ArgTypes...
2453 	      >::type
2454 	    { };
2455 	
2456 	  template<typename _Functor, typename... _ArgTypes>
2457 	    struct result_of<_Functor(_ArgTypes...)>
2458 	    : public __invoke_result<_Functor, _ArgTypes...>
2459 	    { };
2460 	
2461 	#if __cplusplus >= 201402L
2462 	  /// Alias template for aligned_storage
2463 	  template<size_t _Len, size_t _Align =
2464 		    __alignof__(typename __aligned_storage_msa<_Len>::__type)>
2465 	    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
2466 	
2467 	  template <size_t _Len, typename... _Types>
2468 	    using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
2469 	
2470 	  /// Alias template for decay
2471 	  template<typename _Tp>
2472 	    using decay_t = typename decay<_Tp>::type;
2473 	
2474 	  /// Alias template for enable_if
2475 	  template<bool _Cond, typename _Tp = void>
2476 	    using enable_if_t = typename enable_if<_Cond, _Tp>::type;
2477 	
2478 	  /// Alias template for conditional
2479 	  template<bool _Cond, typename _Iftrue, typename _Iffalse>
2480 	    using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
2481 	
2482 	  /// Alias template for common_type
2483 	  template<typename... _Tp>
2484 	    using common_type_t = typename common_type<_Tp...>::type;
2485 	
2486 	  /// Alias template for underlying_type
2487 	  template<typename _Tp>
2488 	    using underlying_type_t = typename underlying_type<_Tp>::type;
2489 	
2490 	  /// Alias template for result_of
2491 	  template<typename _Tp>
2492 	    using result_of_t = typename result_of<_Tp>::type;
2493 	#endif // C++14
2494 	
2495 	  // __enable_if_t (std::enable_if_t for C++11)
2496 	  template<bool _Cond, typename _Tp = void>
2497 	    using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
2498 	
2499 	  // __void_t (std::void_t for C++11)
2500 	  template<typename...> using __void_t = void;
2501 	
2502 	#if __cplusplus >= 201703L || !defined(__STRICT_ANSI__) // c++17 or gnu++11
2503 	#define __cpp_lib_void_t 201411
2504 	  /// A metafunction that always yields void, used for detecting valid types.
2505 	  template<typename...> using void_t = void;
2506 	#endif
2507 	
2508 	  /// Implementation of the detection idiom (negative case).
2509 	  template<typename _Default, typename _AlwaysVoid,
2510 		   template<typename...> class _Op, typename... _Args>
2511 	    struct __detector
2512 	    {
2513 	      using value_t = false_type;
2514 	      using type = _Default;
2515 	    };
2516 	
2517 	  /// Implementation of the detection idiom (positive case).
2518 	  template<typename _Default, template<typename...> class _Op,
2519 		    typename... _Args>
2520 	    struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
2521 	    {
2522 	      using value_t = true_type;
2523 	      using type = _Op<_Args...>;
2524 	    };
2525 	
2526 	  // Detect whether _Op<_Args...> is a valid type, use _Default if not.
2527 	  template<typename _Default, template<typename...> class _Op,
2528 		   typename... _Args>
2529 	    using __detected_or = __detector<_Default, void, _Op, _Args...>;
2530 	
2531 	  // _Op<_Args...> if that is a valid type, otherwise _Default.
2532 	  template<typename _Default, template<typename...> class _Op,
2533 		   typename... _Args>
2534 	    using __detected_or_t
2535 	      = typename __detected_or<_Default, _Op, _Args...>::type;
2536 	
2537 	  /// @} group metaprogramming
2538 	
2539 	  /**
2540 	   *  Use SFINAE to determine if the type _Tp has a publicly-accessible
2541 	   *  member type _NTYPE.
2542 	   */
2543 	#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE)				\
2544 	  template<typename _Tp, typename = __void_t<>>				\
2545 	    struct __has_##_NTYPE						\
2546 	    : false_type							\
2547 	    { };								\
2548 	  template<typename _Tp>						\
2549 	    struct __has_##_NTYPE<_Tp, __void_t<typename _Tp::_NTYPE>>		\
2550 	    : true_type								\
2551 	    { };
2552 	
2553 	  template <typename _Tp>
2554 	    struct __is_swappable;
2555 	
2556 	  template <typename _Tp>
2557 	    struct __is_nothrow_swappable;
2558 	
2559 	  template<typename... _Elements>
2560 	    class tuple;
2561 	
2562 	  template<typename>
2563 	    struct __is_tuple_like_impl : false_type
2564 	    { };
2565 	
2566 	  template<typename... _Tps>
2567 	    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
2568 	    { };
2569 	
2570 	  // Internal type trait that allows us to sfinae-protect tuple_cat.
2571 	  template<typename _Tp>
2572 	    struct __is_tuple_like
2573 	    : public __is_tuple_like_impl<typename remove_cv<
2574 	      typename remove_reference<_Tp>::type>::type>::type
2575 	    { };
2576 	
2577 	  template<typename _Tp>
2578 	    inline
2579 	    typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
2580 				      is_move_constructible<_Tp>,
2581 				      is_move_assignable<_Tp>>::value>::type
2582 	    swap(_Tp&, _Tp&)
2583 	    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
2584 		            is_nothrow_move_assignable<_Tp>>::value);
2585 	
2586 	  template<typename _Tp, size_t _Nm>
2587 	    inline
2588 	    typename enable_if<__is_swappable<_Tp>::value>::type
2589 	    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
2590 	    noexcept(__is_nothrow_swappable<_Tp>::value);
2591 	
2592 	  namespace __swappable_details {
2593 	    using std::swap;
2594 	
2595 	    struct __do_is_swappable_impl
2596 	    {
2597 	      template<typename _Tp, typename
2598 	               = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
2599 	        static true_type __test(int);
2600 	
2601 	      template<typename>
2602 	        static false_type __test(...);
2603 	    };
2604 	
2605 	    struct __do_is_nothrow_swappable_impl
2606 	    {
2607 	      template<typename _Tp>
2608 	        static __bool_constant<
2609 	          noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2610 	        > __test(int);
2611 	
2612 	      template<typename>
2613 	        static false_type __test(...);
2614 	    };
2615 	
2616 	  } // namespace __swappable_details
2617 	
2618 	  template<typename _Tp>
2619 	    struct __is_swappable_impl
2620 	    : public __swappable_details::__do_is_swappable_impl
2621 	    {
2622 	      typedef decltype(__test<_Tp>(0)) type;
2623 	    };
2624 	
2625 	  template<typename _Tp>
2626 	    struct __is_nothrow_swappable_impl
2627 	    : public __swappable_details::__do_is_nothrow_swappable_impl
2628 	    {
2629 	      typedef decltype(__test<_Tp>(0)) type;
2630 	    };
2631 	
2632 	  template<typename _Tp>
2633 	    struct __is_swappable
2634 	    : public __is_swappable_impl<_Tp>::type
2635 	    { };
2636 	
2637 	  template<typename _Tp>
2638 	    struct __is_nothrow_swappable
2639 	    : public __is_nothrow_swappable_impl<_Tp>::type
2640 	    { };
2641 	
2642 	#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
2643 	#define __cpp_lib_is_swappable 201603
2644 	  /// Metafunctions used for detecting swappable types: p0185r1
2645 	
2646 	  /// is_swappable
2647 	  template<typename _Tp>
2648 	    struct is_swappable
2649 	    : public __is_swappable_impl<_Tp>::type
2650 	    { };
2651 	
2652 	  /// is_nothrow_swappable
2653 	  template<typename _Tp>
2654 	    struct is_nothrow_swappable
2655 	    : public __is_nothrow_swappable_impl<_Tp>::type
2656 	    { };
2657 	
2658 	#if __cplusplus >= 201402L
2659 	  /// is_swappable_v
2660 	  template<typename _Tp>
2661 	    _GLIBCXX17_INLINE constexpr bool is_swappable_v =
2662 	      is_swappable<_Tp>::value;
2663 	
2664 	  /// is_nothrow_swappable_v
2665 	  template<typename _Tp>
2666 	    _GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_v =
2667 	      is_nothrow_swappable<_Tp>::value;
2668 	#endif // __cplusplus >= 201402L
2669 	
2670 	  namespace __swappable_with_details {
2671 	    using std::swap;
2672 	
2673 	    struct __do_is_swappable_with_impl
2674 	    {
2675 	      template<typename _Tp, typename _Up, typename
2676 	               = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
2677 	               typename
2678 	               = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
2679 	        static true_type __test(int);
2680 	
2681 	      template<typename, typename>
2682 	        static false_type __test(...);
2683 	    };
2684 	
2685 	    struct __do_is_nothrow_swappable_with_impl
2686 	    {
2687 	      template<typename _Tp, typename _Up>
2688 	        static __bool_constant<
2689 	          noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
2690 	          &&
2691 	          noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
2692 	        > __test(int);
2693 	
2694 	      template<typename, typename>
2695 	        static false_type __test(...);
2696 	    };
2697 	
2698 	  } // namespace __swappable_with_details
2699 	
2700 	  template<typename _Tp, typename _Up>
2701 	    struct __is_swappable_with_impl
2702 	    : public __swappable_with_details::__do_is_swappable_with_impl
2703 	    {
2704 	      typedef decltype(__test<_Tp, _Up>(0)) type;
2705 	    };
2706 	
2707 	  // Optimization for the homogenous lvalue case, not required:
2708 	  template<typename _Tp>
2709 	    struct __is_swappable_with_impl<_Tp&, _Tp&>
2710 	    : public __swappable_details::__do_is_swappable_impl
2711 	    {
2712 	      typedef decltype(__test<_Tp&>(0)) type;
2713 	    };
2714 	
2715 	  template<typename _Tp, typename _Up>
2716 	    struct __is_nothrow_swappable_with_impl
2717 	    : public __swappable_with_details::__do_is_nothrow_swappable_with_impl
2718 	    {
2719 	      typedef decltype(__test<_Tp, _Up>(0)) type;
2720 	    };
2721 	
2722 	  // Optimization for the homogenous lvalue case, not required:
2723 	  template<typename _Tp>
2724 	    struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
2725 	    : public __swappable_details::__do_is_nothrow_swappable_impl
2726 	    {
2727 	      typedef decltype(__test<_Tp&>(0)) type;
2728 	    };
2729 	
2730 	  /// is_swappable_with
2731 	  template<typename _Tp, typename _Up>
2732 	    struct is_swappable_with
2733 	    : public __is_swappable_with_impl<_Tp, _Up>::type
2734 	    { };
2735 	
2736 	  /// is_nothrow_swappable_with
2737 	  template<typename _Tp, typename _Up>
2738 	    struct is_nothrow_swappable_with
2739 	    : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
2740 	    { };
2741 	
2742 	#if __cplusplus >= 201402L
2743 	  /// is_swappable_with_v
2744 	  template<typename _Tp, typename _Up>
2745 	    _GLIBCXX17_INLINE constexpr bool is_swappable_with_v =
2746 	      is_swappable_with<_Tp, _Up>::value;
2747 	
2748 	  /// is_nothrow_swappable_with_v
2749 	  template<typename _Tp, typename _Up>
2750 	    _GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_with_v =
2751 	      is_nothrow_swappable_with<_Tp, _Up>::value;
2752 	#endif // __cplusplus >= 201402L
2753 	
2754 	#endif// c++1z or gnu++11
2755 	
2756 	  // __is_invocable (std::is_invocable for C++11)
2757 	
2758 	  template<typename _Result, typename _Ret, typename = void>
2759 	    struct __is_invocable_impl : false_type { };
2760 	
2761 	  template<typename _Result, typename _Ret>
2762 	    struct __is_invocable_impl<_Result, _Ret, __void_t<typename _Result::type>>
2763 	    : __or_<is_void<_Ret>, is_convertible<typename _Result::type, _Ret>>::type
2764 	    { };
2765 	
2766 	  template<typename _Fn, typename... _ArgTypes>
2767 	    struct __is_invocable
2768 	    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
2769 	    { };
2770 	
2771 	  template<typename _Fn, typename _Tp, typename... _Args>
2772 	    constexpr bool __call_is_nt(__invoke_memfun_ref)
2773 	    {
2774 	      using _Up = typename __inv_unwrap<_Tp>::type;
2775 	      return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
2776 		    std::declval<_Args>()...));
2777 	    }
2778 	
2779 	  template<typename _Fn, typename _Tp, typename... _Args>
2780 	    constexpr bool __call_is_nt(__invoke_memfun_deref)
2781 	    {
2782 	      return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
2783 		    std::declval<_Args>()...));
2784 	    }
2785 	
2786 	  template<typename _Fn, typename _Tp>
2787 	    constexpr bool __call_is_nt(__invoke_memobj_ref)
2788 	    {
2789 	      using _Up = typename __inv_unwrap<_Tp>::type;
2790 	      return noexcept(std::declval<_Up>().*std::declval<_Fn>());
2791 	    }
2792 	
2793 	  template<typename _Fn, typename _Tp>
2794 	    constexpr bool __call_is_nt(__invoke_memobj_deref)
2795 	    {
2796 	      return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
2797 	    }
2798 	
2799 	  template<typename _Fn, typename... _Args>
2800 	    constexpr bool __call_is_nt(__invoke_other)
2801 	    {
2802 	      return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
2803 	    }
2804 	
2805 	  template<typename _Result, typename _Fn, typename... _Args>
2806 	    struct __call_is_nothrow
2807 	    : __bool_constant<
2808 		std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
2809 	      >
2810 	    { };
2811 	
2812 	  template<typename _Fn, typename... _Args>
2813 	    using __call_is_nothrow_
2814 	      = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
2815 	
2816 	  // __is_nothrow_invocable (std::is_nothrow_invocable for C++11)
2817 	  template<typename _Fn, typename... _Args>
2818 	    struct __is_nothrow_invocable
2819 	    : __and_<__is_invocable<_Fn, _Args...>,
2820 	             __call_is_nothrow_<_Fn, _Args...>>::type
2821 	    { };
2822 	
2823 	  struct __nonesuch {
2824 	    __nonesuch() = delete;
2825 	    ~__nonesuch() = delete;
2826 	    __nonesuch(__nonesuch const&) = delete;
2827 	    void operator=(__nonesuch const&) = delete;
2828 	  };
2829 	
2830 	#if __cplusplus > 201402L
2831 	# define __cpp_lib_is_invocable 201703
2832 	
2833 	  /// std::invoke_result
2834 	  template<typename _Functor, typename... _ArgTypes>
2835 	    struct invoke_result
2836 	    : public __invoke_result<_Functor, _ArgTypes...>
2837 	    { };
2838 	
2839 	  /// std::invoke_result_t
2840 	  template<typename _Fn, typename... _Args>
2841 	    using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
2842 	
2843 	  /// std::is_invocable
2844 	  template<typename _Fn, typename... _ArgTypes>
2845 	    struct is_invocable
2846 	    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
2847 	    { };
2848 	
2849 	  /// std::is_invocable_r
2850 	  template<typename _Ret, typename _Fn, typename... _ArgTypes>
2851 	    struct is_invocable_r
2852 	    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type
2853 	    { };
2854 	
2855 	  /// std::is_nothrow_invocable
2856 	  template<typename _Fn, typename... _ArgTypes>
2857 	    struct is_nothrow_invocable
2858 	    : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
2859 	             __call_is_nothrow_<_Fn, _ArgTypes...>>::type
2860 	    { };
2861 	
2862 	  template<typename _Result, typename _Ret, typename = void>
2863 	    struct __is_nt_invocable_impl : false_type { };
2864 	
2865 	  template<typename _Result, typename _Ret>
2866 	    struct __is_nt_invocable_impl<_Result, _Ret,
2867 					  __void_t<typename _Result::type>>
2868 	    : __or_<is_void<_Ret>,
2869 		    __and_<is_convertible<typename _Result::type, _Ret>,
2870 			   is_nothrow_constructible<_Ret, typename _Result::type>>>
2871 	    { };
2872 	
2873 	  /// std::is_nothrow_invocable_r
2874 	  template<typename _Ret, typename _Fn, typename... _ArgTypes>
2875 	    struct is_nothrow_invocable_r
2876 	    : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
2877 	             __call_is_nothrow_<_Fn, _ArgTypes...>>::type
2878 	    { };
2879 	
2880 	  /// std::is_invocable_v
2881 	  template<typename _Fn, typename... _Args>
2882 	    inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
2883 	
2884 	  /// std::is_nothrow_invocable_v
2885 	  template<typename _Fn, typename... _Args>
2886 	    inline constexpr bool is_nothrow_invocable_v
2887 	      = is_nothrow_invocable<_Fn, _Args...>::value;
2888 	
2889 	  /// std::is_invocable_r_v
2890 	  template<typename _Fn, typename... _Args>
2891 	    inline constexpr bool is_invocable_r_v
2892 	      = is_invocable_r<_Fn, _Args...>::value;
2893 	
2894 	  /// std::is_nothrow_invocable_r_v
2895 	  template<typename _Fn, typename... _Args>
2896 	    inline constexpr bool is_nothrow_invocable_r_v
2897 	      = is_nothrow_invocable_r<_Fn, _Args...>::value;
2898 	#endif // C++17
2899 	
2900 	#if __cplusplus > 201402L
2901 	# define __cpp_lib_type_trait_variable_templates 201510L
2902 	template <typename _Tp>
2903 	  inline constexpr bool is_void_v = is_void<_Tp>::value;
2904 	template <typename _Tp>
2905 	  inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
2906 	template <typename _Tp>
2907 	  inline constexpr bool is_integral_v = is_integral<_Tp>::value;
2908 	template <typename _Tp>
2909 	  inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
2910 	template <typename _Tp>
2911 	  inline constexpr bool is_array_v = is_array<_Tp>::value;
2912 	template <typename _Tp>
2913 	  inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
2914 	template <typename _Tp>
2915 	  inline constexpr bool is_lvalue_reference_v =
2916 	    is_lvalue_reference<_Tp>::value;
2917 	template <typename _Tp>
2918 	  inline constexpr bool is_rvalue_reference_v =
2919 	    is_rvalue_reference<_Tp>::value;
2920 	template <typename _Tp>
2921 	  inline constexpr bool is_member_object_pointer_v =
2922 	    is_member_object_pointer<_Tp>::value;
2923 	template <typename _Tp>
2924 	  inline constexpr bool is_member_function_pointer_v =
2925 	    is_member_function_pointer<_Tp>::value;
2926 	template <typename _Tp>
2927 	  inline constexpr bool is_enum_v = is_enum<_Tp>::value;
2928 	template <typename _Tp>
2929 	  inline constexpr bool is_union_v = is_union<_Tp>::value;
2930 	template <typename _Tp>
2931 	  inline constexpr bool is_class_v = is_class<_Tp>::value;
2932 	template <typename _Tp>
2933 	  inline constexpr bool is_function_v = is_function<_Tp>::value;
2934 	template <typename _Tp>
2935 	  inline constexpr bool is_reference_v = is_reference<_Tp>::value;
2936 	template <typename _Tp>
2937 	  inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
2938 	template <typename _Tp>
2939 	  inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
2940 	template <typename _Tp>
2941 	  inline constexpr bool is_object_v = is_object<_Tp>::value;
2942 	template <typename _Tp>
2943 	  inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
2944 	template <typename _Tp>
2945 	  inline constexpr bool is_compound_v = is_compound<_Tp>::value;
2946 	template <typename _Tp>
2947 	  inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
2948 	template <typename _Tp>
2949 	  inline constexpr bool is_const_v = is_const<_Tp>::value;
2950 	template <typename _Tp>
2951 	  inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
2952 	template <typename _Tp>
2953 	  inline constexpr bool is_trivial_v = is_trivial<_Tp>::value;
2954 	template <typename _Tp>
2955 	  inline constexpr bool is_trivially_copyable_v =
2956 	    is_trivially_copyable<_Tp>::value;
2957 	template <typename _Tp>
2958 	  inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value;
2959 	template <typename _Tp>
2960 	  inline constexpr bool is_pod_v = is_pod<_Tp>::value;
2961 	template <typename _Tp>
2962 	  inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value;
2963 	template <typename _Tp>
2964 	  inline constexpr bool is_empty_v = is_empty<_Tp>::value;
2965 	template <typename _Tp>
2966 	  inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value;
2967 	template <typename _Tp>
2968 	  inline constexpr bool is_abstract_v = is_abstract<_Tp>::value;
2969 	template <typename _Tp>
2970 	  inline constexpr bool is_final_v = is_final<_Tp>::value;
2971 	template <typename _Tp>
2972 	  inline constexpr bool is_signed_v = is_signed<_Tp>::value;
2973 	template <typename _Tp>
2974 	  inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
2975 	template <typename _Tp, typename... _Args>
2976 	  inline constexpr bool is_constructible_v =
2977 	    is_constructible<_Tp, _Args...>::value;
2978 	template <typename _Tp>
2979 	  inline constexpr bool is_default_constructible_v =
2980 	    is_default_constructible<_Tp>::value;
2981 	template <typename _Tp>
2982 	  inline constexpr bool is_copy_constructible_v =
2983 	    is_copy_constructible<_Tp>::value;
2984 	template <typename _Tp>
2985 	  inline constexpr bool is_move_constructible_v =
2986 	    is_move_constructible<_Tp>::value;
2987 	template <typename _Tp, typename _Up>
2988 	  inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value;
2989 	template <typename _Tp>
2990 	  inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
2991 	template <typename _Tp>
2992 	  inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
2993 	template <typename _Tp>
2994 	  inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;
2995 	template <typename _Tp, typename... _Args>
2996 	  inline constexpr bool is_trivially_constructible_v =
2997 	    is_trivially_constructible<_Tp, _Args...>::value;
2998 	template <typename _Tp>
2999 	  inline constexpr bool is_trivially_default_constructible_v =
3000 	    is_trivially_default_constructible<_Tp>::value;
3001 	template <typename _Tp>
3002 	  inline constexpr bool is_trivially_copy_constructible_v =
3003 	    is_trivially_copy_constructible<_Tp>::value;
3004 	template <typename _Tp>
3005 	  inline constexpr bool is_trivially_move_constructible_v =
3006 	    is_trivially_move_constructible<_Tp>::value;
3007 	template <typename _Tp, typename _Up>
3008 	  inline constexpr bool is_trivially_assignable_v =
3009 	    is_trivially_assignable<_Tp, _Up>::value;
3010 	template <typename _Tp>
3011 	  inline constexpr bool is_trivially_copy_assignable_v =
3012 	    is_trivially_copy_assignable<_Tp>::value;
3013 	template <typename _Tp>
3014 	  inline constexpr bool is_trivially_move_assignable_v =
3015 	    is_trivially_move_assignable<_Tp>::value;
3016 	template <typename _Tp>
3017 	  inline constexpr bool is_trivially_destructible_v =
3018 	    is_trivially_destructible<_Tp>::value;
3019 	template <typename _Tp, typename... _Args>
3020 	  inline constexpr bool is_nothrow_constructible_v =
3021 	    is_nothrow_constructible<_Tp, _Args...>::value;
3022 	template <typename _Tp>
3023 	  inline constexpr bool is_nothrow_default_constructible_v =
3024 	    is_nothrow_default_constructible<_Tp>::value;
3025 	template <typename _Tp>
3026 	  inline constexpr bool is_nothrow_copy_constructible_v =
3027 	    is_nothrow_copy_constructible<_Tp>::value;
3028 	template <typename _Tp>
3029 	  inline constexpr bool is_nothrow_move_constructible_v =
3030 	    is_nothrow_move_constructible<_Tp>::value;
3031 	template <typename _Tp, typename _Up>
3032 	  inline constexpr bool is_nothrow_assignable_v =
3033 	    is_nothrow_assignable<_Tp, _Up>::value;
3034 	template <typename _Tp>
3035 	  inline constexpr bool is_nothrow_copy_assignable_v =
3036 	    is_nothrow_copy_assignable<_Tp>::value;
3037 	template <typename _Tp>
3038 	  inline constexpr bool is_nothrow_move_assignable_v =
3039 	    is_nothrow_move_assignable<_Tp>::value;
3040 	template <typename _Tp>
3041 	  inline constexpr bool is_nothrow_destructible_v =
3042 	    is_nothrow_destructible<_Tp>::value;
3043 	template <typename _Tp>
3044 	  inline constexpr bool has_virtual_destructor_v =
3045 	    has_virtual_destructor<_Tp>::value;
3046 	template <typename _Tp>
3047 	  inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
3048 	template <typename _Tp>
3049 	  inline constexpr size_t rank_v = rank<_Tp>::value;
3050 	template <typename _Tp, unsigned _Idx = 0>
3051 	  inline constexpr size_t extent_v = extent<_Tp, _Idx>::value;
3052 	template <typename _Tp, typename _Up>
3053 	  inline constexpr bool is_same_v = is_same<_Tp, _Up>::value;
3054 	template <typename _Base, typename _Derived>
3055 	  inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value;
3056 	template <typename _From, typename _To>
3057 	  inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
3058 	
3059 	#if __GNUC__ >= 7
3060 	# define _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 1
3061 	#elif defined(__is_identifier)
3062 	// For non-GNU compilers:
3063 	# if ! __is_identifier(__has_unique_object_representations)
3064 	#  define _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 1
3065 	# endif
3066 	#endif
3067 	
3068 	#ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP
3069 	# define __cpp_lib_has_unique_object_representations 201606
3070 	  /// has_unique_object_representations
3071 	  template<typename _Tp>
3072 	    struct has_unique_object_representations
3073 	    : bool_constant<__has_unique_object_representations(
3074 	      remove_cv_t<remove_all_extents_t<_Tp>>
3075 	      )>
3076 	    { };
3077 	
3078 	  template<typename _Tp>
3079 	    inline constexpr bool has_unique_object_representations_v
3080 	      = has_unique_object_representations<_Tp>::value;
3081 	#endif
3082 	#undef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP
3083 	
3084 	#if __GNUC__ >= 7
3085 	# define _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 1
3086 	#elif defined(__is_identifier)
3087 	// For non-GNU compilers:
3088 	# if ! __is_identifier(__is_aggregate)
3089 	#  define _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 1
3090 	# endif
3091 	#endif
3092 	
3093 	#ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE
3094 	#define __cpp_lib_is_aggregate 201703
3095 	  /// is_aggregate
3096 	  template<typename _Tp>
3097 	    struct is_aggregate
3098 	    : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> { };
3099 	
3100 	  /// is_aggregate_v
3101 	  template<typename _Tp>
3102 	    inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value;
3103 	#endif
3104 	#undef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE
3105 	
3106 	#endif // C++17
3107 	
3108 	_GLIBCXX_END_NAMESPACE_VERSION
3109 	} // namespace std
3110 	
3111 	#endif  // C++11
3112 	
3113 	#endif  // _GLIBCXX_TYPE_TRAITS
3114