From 23d41fba714cd55847f28d4ea8f48f736195ba72 Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Thu, 25 Jan 2018 18:33:07 -0500
Subject: [PATCH 46/49] FIXME: PR 84045 reduced

---
 pr84045.C | 12688 +-----------------------------------------------------------
 1 file changed, 10 insertions(+), 12678 deletions(-)

diff --git a/pr84045.C b/pr84045.C
index e210d30..ec66af8 100644
--- a/pr84045.C
+++ b/pr84045.C
@@ -1,12681 +1,13 @@
-# 1 "/tmp/test.C"
-# 1 "<built-in>"
-# 1 "<command-line>"
-# 1 "/usr/include/stdc-predef.h" 1 3 4
-# 1 "<command-line>" 2
-# 1 "/tmp/test.C"
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 1
-# 32 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits"
-       
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
+template <typename _Tp> struct is_nothrow_default_constructible {};
 
+template <typename T, typename S> struct dummy {
+  typedef is_nothrow_default_constructible<T> dc;
+  void fu() noexcept(dc::value) {}
+};
 
+template <typename _Key_compare> struct _Rb_tree_key_compare {
+  _Rb_tree_key_compare()
+  noexcept(is_nothrow_default_constructible<_Key_compare>::value) {}
+};
 
-
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++config.h" 1 3
-# 236 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++config.h" 3
-
-# 236 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++config.h" 3
-namespace std
-{
-  typedef long unsigned int size_t;
-  typedef long int ptrdiff_t;
-
-
-  typedef decltype(nullptr) nullptr_t;
-
-}
-# 258 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++config.h" 3
-namespace std
-{
-  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
-}
-namespace __gnu_cxx
-{
-  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
-}
-# 508 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++config.h" 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3
-# 39 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/os_defines.h" 3
-# 1 "/usr/include/features.h" 1 3 4
-# 364 "/usr/include/features.h" 3 4
-# 1 "/usr/include/sys/cdefs.h" 1 3 4
-# 385 "/usr/include/sys/cdefs.h" 3 4
-# 1 "/usr/include/bits/wordsize.h" 1 3 4
-# 386 "/usr/include/sys/cdefs.h" 2 3 4
-# 365 "/usr/include/features.h" 2 3 4
-# 388 "/usr/include/features.h" 3 4
-# 1 "/usr/include/gnu/stubs.h" 1 3 4
-# 10 "/usr/include/gnu/stubs.h" 3 4
-# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
-# 11 "/usr/include/gnu/stubs.h" 2 3 4
-# 389 "/usr/include/features.h" 2 3 4
-# 40 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3
-# 509 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
-
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3
-# 512 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
-# 39 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 2 3
-
-
-
-namespace std
-{
-  typedef short unsigned int uint_least16_t;
-  typedef unsigned int uint_least32_t;
-}
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-# 68 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template<typename _Tp, _Tp __v>
-    struct integral_constant
-    {
-      static constexpr _Tp value = __v;
-      typedef _Tp value_type;
-      typedef integral_constant<_Tp, __v> type;
-      constexpr operator value_type() const noexcept { return value; }
-
-
-
-
-      constexpr value_type operator()() const noexcept { return value; }
-
-    };
-
-  template<typename _Tp, _Tp __v>
-    constexpr _Tp integral_constant<_Tp, __v>::value;
-
-
-  typedef integral_constant<bool, true> true_type;
-
-
-  typedef integral_constant<bool, false> false_type;
-
-  template<bool __v>
-    using __bool_constant = integral_constant<bool, __v>;
-# 103 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template<bool, typename, typename>
-    struct conditional;
-
-  template<typename...>
-    struct __or_;
-
-  template<>
-    struct __or_<>
-    : public false_type
-    { };
-
-  template<typename _B1>
-    struct __or_<_B1>
-    : public _B1
-    { };
-
-  template<typename _B1, typename _B2>
-    struct __or_<_B1, _B2>
-    : public conditional<_B1::value, _B1, _B2>::type
-    { };
-
-  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
-    struct __or_<_B1, _B2, _B3, _Bn...>
-    : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
-    { };
-
-  template<typename...>
-    struct __and_;
-
-  template<>
-    struct __and_<>
-    : public true_type
-    { };
-
-  template<typename _B1>
-    struct __and_<_B1>
-    : public _B1
-    { };
-
-  template<typename _B1, typename _B2>
-    struct __and_<_B1, _B2>
-    : public conditional<_B1::value, _B2, _B1>::type
-    { };
-
-  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
-    struct __and_<_B1, _B2, _B3, _Bn...>
-    : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
-    { };
-
-  template<typename _Pp>
-    struct __not_
-    : public __bool_constant<!bool(_Pp::value)>
-    { };
-# 192 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template<typename _Tp>
-    struct __success_type
-    { typedef _Tp type; };
-
-  struct __failure_type
-  { };
-
-
-
-  template<typename>
-    struct remove_cv;
-
-  template<typename>
-    struct __is_void_helper
-    : public false_type { };
-
-  template<>
-    struct __is_void_helper<void>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_void
-    : public __is_void_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-  template<typename>
-    struct __is_integral_helper
-    : public false_type { };
-
-  template<>
-    struct __is_integral_helper<bool>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<char>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<signed char>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned char>
-    : public true_type { };
-
-
-  template<>
-    struct __is_integral_helper<wchar_t>
-    : public true_type { };
-
-
-  template<>
-    struct __is_integral_helper<char16_t>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<char32_t>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<short>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned short>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<int>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned int>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<long>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned long>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<long long>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned long long>
-    : public true_type { };
-
-
-
-
-  template<>
-    struct __is_integral_helper<__int128>
-    : public true_type { };
-
-  template<>
-    struct __is_integral_helper<unsigned __int128>
-    : public true_type { };
-# 324 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template<typename _Tp>
-    struct is_integral
-    : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-  template<typename>
-    struct __is_floating_point_helper
-    : public false_type { };
-
-  template<>
-    struct __is_floating_point_helper<float>
-    : public true_type { };
-
-  template<>
-    struct __is_floating_point_helper<double>
-    : public true_type { };
-
-  template<>
-    struct __is_floating_point_helper<long double>
-    : public true_type { };
-
-
-  template<>
-    struct __is_floating_point_helper<__float128>
-    : public true_type { };
-
-
-
-  template<typename _Tp>
-    struct is_floating_point
-    : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-
-  template<typename>
-    struct is_array
-    : public false_type { };
-
-  template<typename _Tp, std::size_t _Size>
-    struct is_array<_Tp[_Size]>
-    : public true_type { };
-
-  template<typename _Tp>
-    struct is_array<_Tp[]>
-    : public true_type { };
-
-  template<typename>
-    struct __is_pointer_helper
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_pointer_helper<_Tp*>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_pointer
-    : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-
-  template<typename>
-    struct is_lvalue_reference
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_lvalue_reference<_Tp&>
-    : public true_type { };
-
-
-  template<typename>
-    struct is_rvalue_reference
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_rvalue_reference<_Tp&&>
-    : public true_type { };
-
-  template<typename>
-    struct is_function;
-
-  template<typename>
-    struct __is_member_object_pointer_helper
-    : public false_type { };
-
-  template<typename _Tp, typename _Cp>
-    struct __is_member_object_pointer_helper<_Tp _Cp::*>
-    : public integral_constant<bool, !is_function<_Tp>::value> { };
-
-
-  template<typename _Tp>
-    struct is_member_object_pointer
-    : public __is_member_object_pointer_helper<
-    typename remove_cv<_Tp>::type>::type
-    { };
-
-  template<typename>
-    struct __is_member_function_pointer_helper
-    : public false_type { };
-
-  template<typename _Tp, typename _Cp>
-    struct __is_member_function_pointer_helper<_Tp _Cp::*>
-    : public integral_constant<bool, is_function<_Tp>::value> { };
-
-
-  template<typename _Tp>
-    struct is_member_function_pointer
-    : public __is_member_function_pointer_helper<
-    typename remove_cv<_Tp>::type>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_enum
-    : public integral_constant<bool, __is_enum(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_union
-    : public integral_constant<bool, __is_union(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_class
-    : public integral_constant<bool, __is_class(_Tp)>
-    { };
-
-
-  template<typename>
-    struct is_function
-    : public false_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) & >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) && >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) & >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) && >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) const >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) const & >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) const && >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) const >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) const & >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) const && >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) volatile >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) volatile & >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) volatile && >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) volatile >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) volatile & >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) volatile && >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) const volatile >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) const volatile & >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes...) const volatile && >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) const volatile >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) const volatile & >
-    : public true_type { };
-
-  template<typename _Res, typename... _ArgTypes >
-    struct is_function<_Res(_ArgTypes......) const volatile && >
-    : public true_type { };
-
-
-
-  template<typename>
-    struct __is_null_pointer_helper
-    : public false_type { };
-
-  template<>
-    struct __is_null_pointer_helper<std::nullptr_t>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_null_pointer
-    : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-
-  template<typename _Tp>
-    struct __is_nullptr_t
-    : public is_null_pointer<_Tp>
-    { };
-
-
-
-
-  template<typename _Tp>
-    struct is_reference
-    : public __or_<is_lvalue_reference<_Tp>,
-                   is_rvalue_reference<_Tp>>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_arithmetic
-    : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_fundamental
-    : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
-     is_null_pointer<_Tp>>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_object
-    : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
-                          is_void<_Tp>>>::type
-    { };
-
-  template<typename>
-    struct is_member_pointer;
-
-
-  template<typename _Tp>
-    struct is_scalar
-    : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
-                   is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_compound
-    : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct __is_member_pointer_helper
-    : public false_type { };
-
-  template<typename _Tp, typename _Cp>
-    struct __is_member_pointer_helper<_Tp _Cp::*>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_member_pointer
-    : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
-    { };
-
-
-
-  template<typename _Tp>
-    struct __is_referenceable
-    : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
-    { };
-
-  template<typename _Res, typename... _Args >
-    struct __is_referenceable<_Res(_Args...) >
-    : public true_type
-    { };
-
-  template<typename _Res, typename... _Args >
-    struct __is_referenceable<_Res(_Args......) >
-    : public true_type
-    { };
-
-
-
-
-  template<typename>
-    struct is_const
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_const<_Tp const>
-    : public true_type { };
-
-
-  template<typename>
-    struct is_volatile
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_volatile<_Tp volatile>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_trivial
-    : public integral_constant<bool, __is_trivial(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_trivially_copyable
-    : public integral_constant<bool, __is_trivially_copyable(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_standard_layout
-    : public integral_constant<bool, __is_standard_layout(_Tp)>
-    { };
-
-
-
-  template<typename _Tp>
-    struct is_pod
-    : public integral_constant<bool, __is_pod(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_literal_type
-    : public integral_constant<bool, __is_literal_type(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_empty
-    : public integral_constant<bool, __is_empty(_Tp)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_polymorphic
-    : public integral_constant<bool, __is_polymorphic(_Tp)>
-    { };
-
-
-
-
-  template<typename _Tp>
-    struct is_final
-    : public integral_constant<bool, __is_final(_Tp)>
-    { };
-
-
-
-  template<typename _Tp>
-    struct is_abstract
-    : public integral_constant<bool, __is_abstract(_Tp)>
-    { };
-
-  template<typename _Tp,
-    bool = is_arithmetic<_Tp>::value>
-    struct __is_signed_helper
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_signed_helper<_Tp, true>
-    : public integral_constant<bool, _Tp(-1) < _Tp(0)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_signed
-    : public __is_signed_helper<_Tp>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_unsigned
-    : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
-    { };
-# 759 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template<typename _Tp, typename _Up = _Tp&&>
-    _Up
-    __declval(int);
-
-  template<typename _Tp>
-    _Tp
-    __declval(long);
-
-  template<typename _Tp>
-    auto declval() noexcept -> decltype(__declval<_Tp>(0));
-
-  template<typename, unsigned = 0>
-    struct extent;
-
-  template<typename>
-    struct remove_all_extents;
-
-  template<typename _Tp>
-    struct __is_array_known_bounds
-    : public integral_constant<bool, (extent<_Tp>::value > 0)>
-    { };
-
-  template<typename _Tp>
-    struct __is_array_unknown_bounds
-    : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
-    { };
-
-
-
-
-
-
-  struct __do_is_destructible_impl
-  {
-    template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
-      static true_type __test(int);
-
-    template<typename>
-      static false_type __test(...);
-  };
-
-  template<typename _Tp>
-    struct __is_destructible_impl
-    : public __do_is_destructible_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp,
-           bool = __or_<is_void<_Tp>,
-                        __is_array_unknown_bounds<_Tp>,
-                        is_function<_Tp>>::value,
-           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
-    struct __is_destructible_safe;
-
-  template<typename _Tp>
-    struct __is_destructible_safe<_Tp, false, false>
-    : public __is_destructible_impl<typename
-               remove_all_extents<_Tp>::type>::type
-    { };
-
-  template<typename _Tp>
-    struct __is_destructible_safe<_Tp, true, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_destructible_safe<_Tp, false, true>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_destructible
-    : public __is_destructible_safe<_Tp>::type
-    { };
-
-
-
-
-
-  struct __do_is_nt_destructible_impl
-  {
-    template<typename _Tp>
-      static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
-        __test(int);
-
-    template<typename>
-      static false_type __test(...);
-  };
-
-  template<typename _Tp>
-    struct __is_nt_destructible_impl
-    : public __do_is_nt_destructible_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp,
-           bool = __or_<is_void<_Tp>,
-                        __is_array_unknown_bounds<_Tp>,
-                        is_function<_Tp>>::value,
-           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
-    struct __is_nt_destructible_safe;
-
-  template<typename _Tp>
-    struct __is_nt_destructible_safe<_Tp, false, false>
-    : public __is_nt_destructible_impl<typename
-               remove_all_extents<_Tp>::type>::type
-    { };
-
-  template<typename _Tp>
-    struct __is_nt_destructible_safe<_Tp, true, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_nt_destructible_safe<_Tp, false, true>
-    : public true_type { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_destructible
-    : public __is_nt_destructible_safe<_Tp>::type
-    { };
-
-  struct __do_is_default_constructible_impl
-  {
-    template<typename _Tp, typename = decltype(_Tp())>
-      static true_type __test(int);
-
-    template<typename>
-      static false_type __test(...);
-  };
-
-  template<typename _Tp>
-    struct __is_default_constructible_impl
-    : public __do_is_default_constructible_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp>
-    struct __is_default_constructible_atom
-    : public __and_<__not_<is_void<_Tp>>,
-                    __is_default_constructible_impl<_Tp>>
-    { };
-
-  template<typename _Tp, bool = is_array<_Tp>::value>
-    struct __is_default_constructible_safe;
-
-
-
-
-
-
-  template<typename _Tp>
-    struct __is_default_constructible_safe<_Tp, true>
-    : public __and_<__is_array_known_bounds<_Tp>,
-      __is_default_constructible_atom<typename
-                      remove_all_extents<_Tp>::type>>
-    { };
-
-  template<typename _Tp>
-    struct __is_default_constructible_safe<_Tp, false>
-    : public __is_default_constructible_atom<_Tp>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_default_constructible
-    : public __is_default_constructible_safe<_Tp>::type
-    { };
-
-
-  template<typename _Tp, typename... _Args>
-    struct is_constructible
-      : public __bool_constant<__is_constructible(_Tp, _Args...)>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_copy_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_copy_constructible_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_copy_constructible_impl<_Tp, true>
-    : public is_constructible<_Tp, const _Tp&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_copy_constructible
-    : public __is_copy_constructible_impl<_Tp>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_move_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_move_constructible_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_move_constructible_impl<_Tp, true>
-    : public is_constructible<_Tp, _Tp&&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_move_constructible
-    : public __is_move_constructible_impl<_Tp>
-    { };
-
-  template<typename _Tp>
-    struct __is_nt_default_constructible_atom
-    : public integral_constant<bool, noexcept(_Tp())>
-    { };
-
-  template<typename _Tp, bool = is_array<_Tp>::value>
-    struct __is_nt_default_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_nt_default_constructible_impl<_Tp, true>
-    : public __and_<__is_array_known_bounds<_Tp>,
-      __is_nt_default_constructible_atom<typename
-                      remove_all_extents<_Tp>::type>>
-    { };
-
-  template<typename _Tp>
-    struct __is_nt_default_constructible_impl<_Tp, false>
-    : public __is_nt_default_constructible_atom<_Tp>
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_default_constructible
-    : public __and_<is_default_constructible<_Tp>,
-                    __is_nt_default_constructible_impl<_Tp>>
-    { };
-
-  template<typename _Tp, typename... _Args>
-    struct __is_nt_constructible_impl
-    : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
-    { };
-
-  template<typename _Tp, typename _Arg>
-    struct __is_nt_constructible_impl<_Tp, _Arg>
-    : public integral_constant<bool,
-                               noexcept(static_cast<_Tp>(declval<_Arg>()))>
-    { };
-
-  template<typename _Tp>
-    struct __is_nt_constructible_impl<_Tp>
-    : public is_nothrow_default_constructible<_Tp>
-    { };
-
-
-  template<typename _Tp, typename... _Args>
-    struct is_nothrow_constructible
-    : public __and_<is_constructible<_Tp, _Args...>,
-      __is_nt_constructible_impl<_Tp, _Args...>>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_nothrow_copy_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_nothrow_copy_constructible_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_nothrow_copy_constructible_impl<_Tp, true>
-    : public is_nothrow_constructible<_Tp, const _Tp&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_copy_constructible
-    : public __is_nothrow_copy_constructible_impl<_Tp>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_nothrow_move_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_nothrow_move_constructible_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_nothrow_move_constructible_impl<_Tp, true>
-    : public is_nothrow_constructible<_Tp, _Tp&&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_move_constructible
-    : public __is_nothrow_move_constructible_impl<_Tp>
-    { };
-
-
-  template<typename _Tp, typename _Up>
-    struct is_assignable
-      : public __bool_constant<__is_assignable(_Tp, _Up)>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_copy_assignable_impl;
-
-  template<typename _Tp>
-    struct __is_copy_assignable_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_copy_assignable_impl<_Tp, true>
-    : public is_assignable<_Tp&, const _Tp&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_copy_assignable
-    : public __is_copy_assignable_impl<_Tp>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_move_assignable_impl;
-
-  template<typename _Tp>
-    struct __is_move_assignable_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_move_assignable_impl<_Tp, true>
-    : public is_assignable<_Tp&, _Tp&&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_move_assignable
-    : public __is_move_assignable_impl<_Tp>
-    { };
-
-  template<typename _Tp, typename _Up>
-    struct __is_nt_assignable_impl
-    : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
-    { };
-
-
-  template<typename _Tp, typename _Up>
-    struct is_nothrow_assignable
-    : public __and_<is_assignable<_Tp, _Up>,
-      __is_nt_assignable_impl<_Tp, _Up>>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_nt_copy_assignable_impl;
-
-  template<typename _Tp>
-    struct __is_nt_copy_assignable_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_nt_copy_assignable_impl<_Tp, true>
-    : public is_nothrow_assignable<_Tp&, const _Tp&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_copy_assignable
-    : public __is_nt_copy_assignable_impl<_Tp>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_nt_move_assignable_impl;
-
-  template<typename _Tp>
-    struct __is_nt_move_assignable_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_nt_move_assignable_impl<_Tp, true>
-    : public is_nothrow_assignable<_Tp&, _Tp&&>
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_move_assignable
-    : public __is_nt_move_assignable_impl<_Tp>
-    { };
-
-
-  template<typename _Tp, typename... _Args>
-    struct is_trivially_constructible
-    : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)>
-    { };
-
-
-  template<typename _Tp>
-    struct is_trivially_default_constructible
-    : public is_trivially_constructible<_Tp>::type
-    { };
-
-  struct __do_is_implicitly_default_constructible_impl
-  {
-    template <typename _Tp>
-    static void __helper(const _Tp&);
-
-    template <typename _Tp>
-    static true_type __test(const _Tp&,
-                            decltype(__helper<const _Tp&>({}))* = 0);
-
-    static false_type __test(...);
-  };
-
-  template<typename _Tp>
-    struct __is_implicitly_default_constructible_impl
-      : public __do_is_implicitly_default_constructible_impl
-  {
-    typedef decltype(__test(declval<_Tp>())) type;
-  };
-
-  template<typename _Tp>
-    struct __is_implicitly_default_constructible_safe
-      : public __is_implicitly_default_constructible_impl<_Tp>::type
-  { };
-
-  template <typename _Tp>
-    struct __is_implicitly_default_constructible
-      : public __and_<is_default_constructible<_Tp>,
-                      __is_implicitly_default_constructible_safe<_Tp>>
-  { };
-
-
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_trivially_copy_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_trivially_copy_constructible_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_trivially_copy_constructible_impl<_Tp, true>
-    : public __and_<is_copy_constructible<_Tp>,
-      integral_constant<bool,
-   __is_trivially_constructible(_Tp, const _Tp&)>>
-    { };
-
-  template<typename _Tp>
-    struct is_trivially_copy_constructible
-    : public __is_trivially_copy_constructible_impl<_Tp>
-    { };
-
-
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_trivially_move_constructible_impl;
-
-  template<typename _Tp>
-    struct __is_trivially_move_constructible_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_trivially_move_constructible_impl<_Tp, true>
-    : public __and_<is_move_constructible<_Tp>,
-      integral_constant<bool,
-   __is_trivially_constructible(_Tp, _Tp&&)>>
-    { };
-
-  template<typename _Tp>
-    struct is_trivially_move_constructible
-    : public __is_trivially_move_constructible_impl<_Tp>
-    { };
-
-
-  template<typename _Tp, typename _Up>
-    struct is_trivially_assignable
-    : public __bool_constant<__is_trivially_assignable(_Tp, _Up)>
-    { };
-
-
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_trivially_copy_assignable_impl;
-
-  template<typename _Tp>
-    struct __is_trivially_copy_assignable_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_trivially_copy_assignable_impl<_Tp, true>
-    : public __and_<is_copy_assignable<_Tp>,
-      integral_constant<bool,
-   __is_trivially_assignable(_Tp&, const _Tp&)>>
-    { };
-
-  template<typename _Tp>
-    struct is_trivially_copy_assignable
-    : public __is_trivially_copy_assignable_impl<_Tp>
-    { };
-
-
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __is_trivially_move_assignable_impl;
-
-  template<typename _Tp>
-    struct __is_trivially_move_assignable_impl<_Tp, false>
-    : public false_type { };
-
-  template<typename _Tp>
-    struct __is_trivially_move_assignable_impl<_Tp, true>
-    : public __and_<is_move_assignable<_Tp>,
-      integral_constant<bool,
-   __is_trivially_assignable(_Tp&, _Tp&&)>>
-    { };
-
-  template<typename _Tp>
-    struct is_trivially_move_assignable
-    : public __is_trivially_move_assignable_impl<_Tp>
-    { };
-
-
-  template<typename _Tp>
-    struct is_trivially_destructible
-    : public __and_<is_destructible<_Tp>, integral_constant<bool,
-         __has_trivial_destructor(_Tp)>>
-    { };
-
-
-
-  template<typename _Tp>
-    struct has_virtual_destructor
-    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
-    { };
-
-
-
-
-
-  template<typename _Tp>
-    struct alignment_of
-    : public integral_constant<std::size_t, __alignof__(_Tp)> { };
-
-
-  template<typename>
-    struct rank
-    : public integral_constant<std::size_t, 0> { };
-
-  template<typename _Tp, std::size_t _Size>
-    struct rank<_Tp[_Size]>
-    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
-
-  template<typename _Tp>
-    struct rank<_Tp[]>
-    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
-
-
-  template<typename, unsigned _Uint>
-    struct extent
-    : public integral_constant<std::size_t, 0> { };
-
-  template<typename _Tp, unsigned _Uint, std::size_t _Size>
-    struct extent<_Tp[_Size], _Uint>
-    : public integral_constant<std::size_t,
-          _Uint == 0 ? _Size : extent<_Tp,
-          _Uint - 1>::value>
-    { };
-
-  template<typename _Tp, unsigned _Uint>
-    struct extent<_Tp[], _Uint>
-    : public integral_constant<std::size_t,
-          _Uint == 0 ? 0 : extent<_Tp,
-             _Uint - 1>::value>
-    { };
-
-
-
-
-
-  template<typename, typename>
-    struct is_same
-    : public false_type { };
-
-  template<typename _Tp>
-    struct is_same<_Tp, _Tp>
-    : public true_type { };
-
-
-  template<typename _Base, typename _Derived>
-    struct is_base_of
-    : public integral_constant<bool, __is_base_of(_Base, _Derived)>
-    { };
-
-  template<typename _From, typename _To,
-           bool = __or_<is_void<_From>, is_function<_To>,
-                        is_array<_To>>::value>
-    struct __is_convertible_helper
-    { typedef typename is_void<_To>::type type; };
-
-  template<typename _From, typename _To>
-    class __is_convertible_helper<_From, _To, false>
-    {
-       template<typename _To1>
- static void __test_aux(_To1);
-
-      template<typename _From1, typename _To1,
-        typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
- static true_type
- __test(int);
-
-      template<typename, typename>
- static false_type
- __test(...);
-
-    public:
-      typedef decltype(__test<_From, _To>(0)) type;
-    };
-
-
-
-  template<typename _From, typename _To>
-    struct is_convertible
-    : public __is_convertible_helper<_From, _To>::type
-    { };
-
-
-
-
-
-  template<typename _Tp>
-    struct remove_const
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct remove_const<_Tp const>
-    { typedef _Tp type; };
-
-
-  template<typename _Tp>
-    struct remove_volatile
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct remove_volatile<_Tp volatile>
-    { typedef _Tp type; };
-
-
-  template<typename _Tp>
-    struct remove_cv
-    {
-      typedef typename
-      remove_const<typename remove_volatile<_Tp>::type>::type type;
-    };
-
-
-  template<typename _Tp>
-    struct add_const
-    { typedef _Tp const type; };
-
-
-  template<typename _Tp>
-    struct add_volatile
-    { typedef _Tp volatile type; };
-
-
-  template<typename _Tp>
-    struct add_cv
-    {
-      typedef typename
-      add_const<typename add_volatile<_Tp>::type>::type type;
-    };
-
-
-
-
-
-
-  template<typename _Tp>
-    using remove_const_t = typename remove_const<_Tp>::type;
-
-
-  template<typename _Tp>
-    using remove_volatile_t = typename remove_volatile<_Tp>::type;
-
-
-  template<typename _Tp>
-    using remove_cv_t = typename remove_cv<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_const_t = typename add_const<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_volatile_t = typename add_volatile<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_cv_t = typename add_cv<_Tp>::type;
-
-
-
-
-
-  template<typename _Tp>
-    struct remove_reference
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct remove_reference<_Tp&>
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct remove_reference<_Tp&&>
-    { typedef _Tp type; };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __add_lvalue_reference_helper
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct __add_lvalue_reference_helper<_Tp, true>
-    { typedef _Tp& type; };
-
-
-  template<typename _Tp>
-    struct add_lvalue_reference
-    : public __add_lvalue_reference_helper<_Tp>
-    { };
-
-  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
-    struct __add_rvalue_reference_helper
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct __add_rvalue_reference_helper<_Tp, true>
-    { typedef _Tp&& type; };
-
-
-  template<typename _Tp>
-    struct add_rvalue_reference
-    : public __add_rvalue_reference_helper<_Tp>
-    { };
-
-
-
-  template<typename _Tp>
-    using remove_reference_t = typename remove_reference<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
-
-
-
-
-
-  template<typename _Unqualified, bool _IsConst, bool _IsVol>
-    struct __cv_selector;
-
-  template<typename _Unqualified>
-    struct __cv_selector<_Unqualified, false, false>
-    { typedef _Unqualified __type; };
-
-  template<typename _Unqualified>
-    struct __cv_selector<_Unqualified, false, true>
-    { typedef volatile _Unqualified __type; };
-
-  template<typename _Unqualified>
-    struct __cv_selector<_Unqualified, true, false>
-    { typedef const _Unqualified __type; };
-
-  template<typename _Unqualified>
-    struct __cv_selector<_Unqualified, true, true>
-    { typedef const volatile _Unqualified __type; };
-
-  template<typename _Qualified, typename _Unqualified,
-    bool _IsConst = is_const<_Qualified>::value,
-    bool _IsVol = is_volatile<_Qualified>::value>
-    class __match_cv_qualifiers
-    {
-      typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
-
-    public:
-      typedef typename __match::__type __type;
-    };
-
-
-  template<typename _Tp>
-    struct __make_unsigned
-    { typedef _Tp __type; };
-
-  template<>
-    struct __make_unsigned<char>
-    { typedef unsigned char __type; };
-
-  template<>
-    struct __make_unsigned<signed char>
-    { typedef unsigned char __type; };
-
-  template<>
-    struct __make_unsigned<short>
-    { typedef unsigned short __type; };
-
-  template<>
-    struct __make_unsigned<int>
-    { typedef unsigned int __type; };
-
-  template<>
-    struct __make_unsigned<long>
-    { typedef unsigned long __type; };
-
-  template<>
-    struct __make_unsigned<long long>
-    { typedef unsigned long long __type; };
-
-
-  template<>
-    struct __make_unsigned<wchar_t> : __make_unsigned<int>
-    { };
-
-
-
-  template<>
-    struct __make_unsigned<__int128>
-    { typedef unsigned __int128 __type; };
-# 1607 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template<typename _Tp,
-    bool _IsInt = is_integral<_Tp>::value,
-    bool _IsEnum = is_enum<_Tp>::value>
-    class __make_unsigned_selector;
-
-  template<typename _Tp>
-    class __make_unsigned_selector<_Tp, true, false>
-    {
-      typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
-      typedef typename __unsignedt::__type __unsigned_type;
-      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
-
-    public:
-      typedef typename __cv_unsigned::__type __type;
-    };
-
-  template<typename _Tp>
-    class __make_unsigned_selector<_Tp, false, true>
-    {
-
-      typedef unsigned char __smallest;
-      static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
-      static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
-      static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
-      static const bool __b3 = sizeof(_Tp) <= sizeof(unsigned long);
-      typedef conditional<__b3, unsigned long, unsigned long long> __cond3;
-      typedef typename __cond3::type __cond3_type;
-      typedef conditional<__b2, unsigned int, __cond3_type> __cond2;
-      typedef typename __cond2::type __cond2_type;
-      typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
-      typedef typename __cond1::type __cond1_type;
-
-      typedef typename conditional<__b0, __smallest, __cond1_type>::type
- __unsigned_type;
-      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
-
-    public:
-      typedef typename __cv_unsigned::__type __type;
-    };
-
-
-
-
-
-  template<typename _Tp>
-    struct make_unsigned
-    { typedef typename __make_unsigned_selector<_Tp>::__type type; };
-
-
-  template<>
-    struct make_unsigned<bool>;
-
-
-
-  template<typename _Tp>
-    struct __make_signed
-    { typedef _Tp __type; };
-
-  template<>
-    struct __make_signed<char>
-    { typedef signed char __type; };
-
-  template<>
-    struct __make_signed<unsigned char>
-    { typedef signed char __type; };
-
-  template<>
-    struct __make_signed<unsigned short>
-    { typedef signed short __type; };
-
-  template<>
-    struct __make_signed<unsigned int>
-    { typedef signed int __type; };
-
-  template<>
-    struct __make_signed<unsigned long>
-    { typedef signed long __type; };
-
-  template<>
-    struct __make_signed<unsigned long long>
-    { typedef signed long long __type; };
-# 1696 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template<>
-    struct __make_signed<char16_t> : __make_signed<uint_least16_t>
-    { };
-  template<>
-    struct __make_signed<char32_t> : __make_signed<uint_least32_t>
-    { };
-
-
-
-  template<>
-    struct __make_signed<unsigned __int128>
-    { typedef __int128 __type; };
-# 1726 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template<typename _Tp,
-    bool _IsInt = is_integral<_Tp>::value,
-    bool _IsEnum = is_enum<_Tp>::value>
-    class __make_signed_selector;
-
-  template<typename _Tp>
-    class __make_signed_selector<_Tp, true, false>
-    {
-      typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
-      typedef typename __signedt::__type __signed_type;
-      typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
-
-    public:
-      typedef typename __cv_signed::__type __type;
-    };
-
-  template<typename _Tp>
-    class __make_signed_selector<_Tp, false, true>
-    {
-      typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
-
-    public:
-      typedef typename __make_signed_selector<__unsigned_type>::__type __type;
-    };
-
-
-
-
-
-  template<typename _Tp>
-    struct make_signed
-    { typedef typename __make_signed_selector<_Tp>::__type type; };
-
-
-  template<>
-    struct make_signed<bool>;
-
-
-
-  template<typename _Tp>
-    using make_signed_t = typename make_signed<_Tp>::type;
-
-
-  template<typename _Tp>
-    using make_unsigned_t = typename make_unsigned<_Tp>::type;
-
-
-
-
-
-  template<typename _Tp>
-    struct remove_extent
-    { typedef _Tp type; };
-
-  template<typename _Tp, std::size_t _Size>
-    struct remove_extent<_Tp[_Size]>
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct remove_extent<_Tp[]>
-    { typedef _Tp type; };
-
-
-  template<typename _Tp>
-    struct remove_all_extents
-    { typedef _Tp type; };
-
-  template<typename _Tp, std::size_t _Size>
-    struct remove_all_extents<_Tp[_Size]>
-    { typedef typename remove_all_extents<_Tp>::type type; };
-
-  template<typename _Tp>
-    struct remove_all_extents<_Tp[]>
-    { typedef typename remove_all_extents<_Tp>::type type; };
-
-
-
-  template<typename _Tp>
-    using remove_extent_t = typename remove_extent<_Tp>::type;
-
-
-  template<typename _Tp>
-    using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
-
-
-
-
-  template<typename _Tp, typename>
-    struct __remove_pointer_helper
-    { typedef _Tp type; };
-
-  template<typename _Tp, typename _Up>
-    struct __remove_pointer_helper<_Tp, _Up*>
-    { typedef _Up type; };
-
-
-  template<typename _Tp>
-    struct remove_pointer
-    : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
-    { };
-
-
-  template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
-          is_void<_Tp>>::value>
-    struct __add_pointer_helper
-    { typedef _Tp type; };
-
-  template<typename _Tp>
-    struct __add_pointer_helper<_Tp, true>
-    { typedef typename remove_reference<_Tp>::type* type; };
-
-  template<typename _Tp>
-    struct add_pointer
-    : public __add_pointer_helper<_Tp>
-    { };
-
-
-
-  template<typename _Tp>
-    using remove_pointer_t = typename remove_pointer<_Tp>::type;
-
-
-  template<typename _Tp>
-    using add_pointer_t = typename add_pointer<_Tp>::type;
-
-
-  template<std::size_t _Len>
-    struct __aligned_storage_msa
-    {
-      union __type
-      {
- unsigned char __data[_Len];
- struct __attribute__((__aligned__)) { } __align;
-      };
-    };
-# 1872 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template<std::size_t _Len, std::size_t _Align =
-    __alignof__(typename __aligned_storage_msa<_Len>::__type)>
-    struct aligned_storage
-    {
-      union type
-      {
- unsigned char __data[_Len];
- struct __attribute__((__aligned__((_Align)))) { } __align;
-      };
-    };
-
-  template <typename... _Types>
-    struct __strictest_alignment
-    {
-      static const size_t _S_alignment = 0;
-      static const size_t _S_size = 0;
-    };
-
-  template <typename _Tp, typename... _Types>
-    struct __strictest_alignment<_Tp, _Types...>
-    {
-      static const size_t _S_alignment =
-        alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
- ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
-      static const size_t _S_size =
-        sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
- ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
-    };
-# 1911 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template <size_t _Len, typename... _Types>
-    struct aligned_union
-    {
-    private:
-      static_assert(sizeof...(_Types) != 0, "At least one type is required");
-
-      using __strictest = __strictest_alignment<_Types...>;
-      static const size_t _S_len = _Len > __strictest::_S_size
- ? _Len : __strictest::_S_size;
-    public:
-
-      static const size_t alignment_value = __strictest::_S_alignment;
-
-      typedef typename aligned_storage<_S_len, alignment_value>::type type;
-    };
-
-  template <size_t _Len, typename... _Types>
-    const size_t aligned_union<_Len, _Types...>::alignment_value;
-
-
-
-  template<typename _Up,
-    bool _IsArray = is_array<_Up>::value,
-    bool _IsFunction = is_function<_Up>::value>
-    struct __decay_selector;
-
-
-  template<typename _Up>
-    struct __decay_selector<_Up, false, false>
-    { typedef typename remove_cv<_Up>::type __type; };
-
-  template<typename _Up>
-    struct __decay_selector<_Up, true, false>
-    { typedef typename remove_extent<_Up>::type* __type; };
-
-  template<typename _Up>
-    struct __decay_selector<_Up, false, true>
-    { typedef typename add_pointer<_Up>::type __type; };
-
-
-  template<typename _Tp>
-    class decay
-    {
-      typedef typename remove_reference<_Tp>::type __remove_type;
-
-    public:
-      typedef typename __decay_selector<__remove_type>::__type type;
-    };
-
-  template<typename _Tp>
-    class reference_wrapper;
-
-
-  template<typename _Tp>
-    struct __strip_reference_wrapper
-    {
-      typedef _Tp __type;
-    };
-
-  template<typename _Tp>
-    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
-    {
-      typedef _Tp& __type;
-    };
-
-  template<typename _Tp>
-    struct __decay_and_strip
-    {
-      typedef typename __strip_reference_wrapper<
- typename decay<_Tp>::type>::__type __type;
-    };
-
-
-
-
-  template<bool, typename _Tp = void>
-    struct enable_if
-    { };
-
-
-  template<typename _Tp>
-    struct enable_if<true, _Tp>
-    { typedef _Tp type; };
-
-  template<typename... _Cond>
-    using _Require = typename enable_if<__and_<_Cond...>::value>::type;
-
-
-
-  template<bool _Cond, typename _Iftrue, typename _Iffalse>
-    struct conditional
-    { typedef _Iftrue type; };
-
-
-  template<typename _Iftrue, typename _Iffalse>
-    struct conditional<false, _Iftrue, _Iffalse>
-    { typedef _Iffalse type; };
-
-
-  template<typename... _Tp>
-    struct common_type;
-
-
-
-  struct __do_common_type_impl
-  {
-    template<typename _Tp, typename _Up>
-      static __success_type<typename decay<decltype
-       (true ? std::declval<_Tp>()
-        : std::declval<_Up>())>::type> _S_test(int);
-
-    template<typename, typename>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _Tp, typename _Up>
-    struct __common_type_impl
-    : private __do_common_type_impl
-    {
-      typedef decltype(_S_test<_Tp, _Up>(0)) type;
-    };
-
-  struct __do_member_type_wrapper
-  {
-    template<typename _Tp>
-      static __success_type<typename _Tp::type> _S_test(int);
-
-    template<typename>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _Tp>
-    struct __member_type_wrapper
-    : private __do_member_type_wrapper
-    {
-      typedef decltype(_S_test<_Tp>(0)) type;
-    };
-
-  template<typename _CTp, typename... _Args>
-    struct __expanded_common_type_wrapper
-    {
-      typedef common_type<typename _CTp::type, _Args...> type;
-    };
-
-  template<typename... _Args>
-    struct __expanded_common_type_wrapper<__failure_type, _Args...>
-    { typedef __failure_type type; };
-
-  template<typename _Tp>
-    struct common_type<_Tp>
-    { typedef typename decay<_Tp>::type type; };
-
-  template<typename _Tp, typename _Up>
-    struct common_type<_Tp, _Up>
-    : public __common_type_impl<_Tp, _Up>::type
-    { };
-
-  template<typename _Tp, typename _Up, typename... _Vp>
-    struct common_type<_Tp, _Up, _Vp...>
-    : public __expanded_common_type_wrapper<typename __member_type_wrapper<
-               common_type<_Tp, _Up>>::type, _Vp...>::type
-    { };
-
-
-  template<typename _Tp>
-    struct underlying_type
-    {
-      typedef __underlying_type(_Tp) type;
-    };
-
-  template<typename _Tp>
-    struct __declval_protector
-    {
-      static const bool __stop = false;
-    };
-
-  template<typename _Tp>
-    auto declval() noexcept -> decltype(__declval<_Tp>(0))
-    {
-      static_assert(__declval_protector<_Tp>::__stop,
-      "declval() must not be used!");
-      return __declval<_Tp>(0);
-    }
-
-
-  template<typename _Signature>
-    class result_of;
-
-
-
-
-
-  struct __invoke_memfun_ref { };
-  struct __invoke_memfun_deref { };
-  struct __invoke_memobj_ref { };
-  struct __invoke_memobj_deref { };
-  struct __invoke_other { };
-
-
-  template<typename _Tp, typename _Tag>
-    struct __result_of_success : __success_type<_Tp>
-    { using __invoke_type = _Tag; };
-
-
-  struct __result_of_memfun_ref_impl
-  {
-    template<typename _Fp, typename _Tp1, typename... _Args>
-      static __result_of_success<decltype(
-      (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
-      ), __invoke_memfun_ref> _S_test(int);
-
-    template<typename...>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _MemPtr, typename _Arg, typename... _Args>
-    struct __result_of_memfun_ref
-    : private __result_of_memfun_ref_impl
-    {
-      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
-    };
-
-
-  struct __result_of_memfun_deref_impl
-  {
-    template<typename _Fp, typename _Tp1, typename... _Args>
-      static __result_of_success<decltype(
-      ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
-      ), __invoke_memfun_deref> _S_test(int);
-
-    template<typename...>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _MemPtr, typename _Arg, typename... _Args>
-    struct __result_of_memfun_deref
-    : private __result_of_memfun_deref_impl
-    {
-      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
-    };
-
-
-  struct __result_of_memobj_ref_impl
-  {
-    template<typename _Fp, typename _Tp1>
-      static __result_of_success<decltype(
-      std::declval<_Tp1>().*std::declval<_Fp>()
-      ), __invoke_memobj_ref> _S_test(int);
-
-    template<typename, typename>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _MemPtr, typename _Arg>
-    struct __result_of_memobj_ref
-    : private __result_of_memobj_ref_impl
-    {
-      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
-    };
-
-
-  struct __result_of_memobj_deref_impl
-  {
-    template<typename _Fp, typename _Tp1>
-      static __result_of_success<decltype(
-      (*std::declval<_Tp1>()).*std::declval<_Fp>()
-      ), __invoke_memobj_deref> _S_test(int);
-
-    template<typename, typename>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _MemPtr, typename _Arg>
-    struct __result_of_memobj_deref
-    : private __result_of_memobj_deref_impl
-    {
-      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
-    };
-
-  template<typename _MemPtr, typename _Arg>
-    struct __result_of_memobj;
-
-  template<typename _Res, typename _Class, typename _Arg>
-    struct __result_of_memobj<_Res _Class::*, _Arg>
-    {
-      typedef typename remove_cv<typename remove_reference<
-        _Arg>::type>::type _Argval;
-      typedef _Res _Class::* _MemPtr;
-      typedef typename conditional<__or_<is_same<_Argval, _Class>,
-        is_base_of<_Class, _Argval>>::value,
-        __result_of_memobj_ref<_MemPtr, _Arg>,
-        __result_of_memobj_deref<_MemPtr, _Arg>
-      >::type::type type;
-    };
-
-  template<typename _MemPtr, typename _Arg, typename... _Args>
-    struct __result_of_memfun;
-
-  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
-    struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
-    {
-      typedef typename remove_cv<typename remove_reference<
-        _Arg>::type>::type _Argval;
-      typedef _Res _Class::* _MemPtr;
-      typedef typename conditional<__or_<is_same<_Argval, _Class>,
-        is_base_of<_Class, _Argval>>::value,
-        __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
-        __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
-      >::type::type type;
-    };
-
-
-
-
-
-
-  template<typename _Tp, typename _Up = typename decay<_Tp>::type>
-    struct __inv_unwrap
-    {
-      using type = _Tp;
-    };
-
-  template<typename _Tp, typename _Up>
-    struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
-    {
-      using type = _Up&;
-    };
-
-  template<bool, bool, typename _Functor, typename... _ArgTypes>
-    struct __result_of_impl
-    {
-      typedef __failure_type type;
-    };
-
-  template<typename _MemPtr, typename _Arg>
-    struct __result_of_impl<true, false, _MemPtr, _Arg>
-    : public __result_of_memobj<typename decay<_MemPtr>::type,
-    typename __inv_unwrap<_Arg>::type>
-    { };
-
-  template<typename _MemPtr, typename _Arg, typename... _Args>
-    struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
-    : public __result_of_memfun<typename decay<_MemPtr>::type,
-    typename __inv_unwrap<_Arg>::type, _Args...>
-    { };
-
-
-  struct __result_of_other_impl
-  {
-    template<typename _Fn, typename... _Args>
-      static __result_of_success<decltype(
-      std::declval<_Fn>()(std::declval<_Args>()...)
-      ), __invoke_other> _S_test(int);
-
-    template<typename...>
-      static __failure_type _S_test(...);
-  };
-
-  template<typename _Functor, typename... _ArgTypes>
-    struct __result_of_impl<false, false, _Functor, _ArgTypes...>
-    : private __result_of_other_impl
-    {
-      typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
-    };
-
-
-  template<typename _Functor, typename... _ArgTypes>
-    struct __invoke_result
-    : public __result_of_impl<
-        is_member_object_pointer<
-          typename remove_reference<_Functor>::type
-        >::value,
-        is_member_function_pointer<
-          typename remove_reference<_Functor>::type
-        >::value,
- _Functor, _ArgTypes...
-      >::type
-    { };
-
-  template<typename _Functor, typename... _ArgTypes>
-    struct result_of<_Functor(_ArgTypes...)>
-    : public __invoke_result<_Functor, _ArgTypes...>
-    { };
-
-
-
-  template<size_t _Len, size_t _Align =
-     __alignof__(typename __aligned_storage_msa<_Len>::__type)>
-    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
-
-  template <size_t _Len, typename... _Types>
-    using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
-
-
-  template<typename _Tp>
-    using decay_t = typename decay<_Tp>::type;
-
-
-  template<bool _Cond, typename _Tp = void>
-    using enable_if_t = typename enable_if<_Cond, _Tp>::type;
-
-
-  template<bool _Cond, typename _Iftrue, typename _Iffalse>
-    using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
-
-
-  template<typename... _Tp>
-    using common_type_t = typename common_type<_Tp...>::type;
-
-
-  template<typename _Tp>
-    using underlying_type_t = typename underlying_type<_Tp>::type;
-
-
-  template<typename _Tp>
-    using result_of_t = typename result_of<_Tp>::type;
-
-
-  template<typename...> using __void_t = void;
-
-
-
-
-  template<typename...> using void_t = void;
-
-
-
-  template<typename _Default, typename _AlwaysVoid,
-    template<typename...> class _Op, typename... _Args>
-    struct __detector
-    {
-      using value_t = false_type;
-      using type = _Default;
-    };
-
-
-  template<typename _Default, template<typename...> class _Op,
-     typename... _Args>
-    struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
-    {
-      using value_t = true_type;
-      using type = _Op<_Args...>;
-    };
-
-
-  template<typename _Default, template<typename...> class _Op,
-    typename... _Args>
-    using __detected_or = __detector<_Default, void, _Op, _Args...>;
-
-
-  template<typename _Default, template<typename...> class _Op,
-    typename... _Args>
-    using __detected_or_t
-      = typename __detected_or<_Default, _Op, _Args...>::type;
-# 2382 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-  template <typename _Tp>
-    struct __is_swappable;
-
-  template <typename _Tp>
-    struct __is_nothrow_swappable;
-
-  template<typename... _Elements>
-    class tuple;
-
-  template<typename>
-    struct __is_tuple_like_impl : false_type
-    { };
-
-  template<typename... _Tps>
-    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
-    { };
-
-
-  template<typename _Tp>
-    struct __is_tuple_like
-    : public __is_tuple_like_impl<typename remove_cv<
-      typename remove_reference<_Tp>::type>::type>::type
-    { };
-
-  template<typename _Tp>
-    inline
-    typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
-         is_move_constructible<_Tp>,
-         is_move_assignable<_Tp>>::value>::type
-    swap(_Tp&, _Tp&)
-    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
-             is_nothrow_move_assignable<_Tp>>::value);
-
-  template<typename _Tp, size_t _Nm>
-    inline
-    typename enable_if<__is_swappable<_Tp>::value>::type
-    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
-    noexcept(__is_nothrow_swappable<_Tp>::value);
-
-  namespace __swappable_details {
-    using std::swap;
-
-    struct __do_is_swappable_impl
-    {
-      template<typename _Tp, typename
-               = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
-        static true_type __test(int);
-
-      template<typename>
-        static false_type __test(...);
-    };
-
-    struct __do_is_nothrow_swappable_impl
-    {
-      template<typename _Tp>
-        static __bool_constant<
-          noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
-        > __test(int);
-
-      template<typename>
-        static false_type __test(...);
-    };
-
-  }
-
-  template<typename _Tp>
-    struct __is_swappable_impl
-    : public __swappable_details::__do_is_swappable_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp>
-    struct __is_nothrow_swappable_impl
-    : public __swappable_details::__do_is_nothrow_swappable_impl
-    {
-      typedef decltype(__test<_Tp>(0)) type;
-    };
-
-  template<typename _Tp>
-    struct __is_swappable
-    : public __is_swappable_impl<_Tp>::type
-    { };
-
-  template<typename _Tp>
-    struct __is_nothrow_swappable
-    : public __is_nothrow_swappable_impl<_Tp>::type
-    { };
-
-
-
-
-
-
-  template<typename _Tp>
-    struct is_swappable
-    : public __is_swappable_impl<_Tp>::type
-    { };
-
-
-  template<typename _Tp>
-    struct is_nothrow_swappable
-    : public __is_nothrow_swappable_impl<_Tp>::type
-    { };
-
-
-
-  template<typename _Tp>
-    constexpr bool is_swappable_v =
-      is_swappable<_Tp>::value;
-
-
-  template<typename _Tp>
-    constexpr bool is_nothrow_swappable_v =
-      is_nothrow_swappable<_Tp>::value;
-
-
-  namespace __swappable_with_details {
-    using std::swap;
-
-    struct __do_is_swappable_with_impl
-    {
-      template<typename _Tp, typename _Up, typename
-               = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
-               typename
-               = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
-        static true_type __test(int);
-
-      template<typename, typename>
-        static false_type __test(...);
-    };
-
-    struct __do_is_nothrow_swappable_with_impl
-    {
-      template<typename _Tp, typename _Up>
-        static __bool_constant<
-          noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
-          &&
-          noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
-        > __test(int);
-
-      template<typename, typename>
-        static false_type __test(...);
-    };
-
-  }
-
-  template<typename _Tp, typename _Up>
-    struct __is_swappable_with_impl
-    : public __swappable_with_details::__do_is_swappable_with_impl
-    {
-      typedef decltype(__test<_Tp, _Up>(0)) type;
-    };
-
-
-  template<typename _Tp>
-    struct __is_swappable_with_impl<_Tp&, _Tp&>
-    : public __swappable_details::__do_is_swappable_impl
-    {
-      typedef decltype(__test<_Tp&>(0)) type;
-    };
-
-  template<typename _Tp, typename _Up>
-    struct __is_nothrow_swappable_with_impl
-    : public __swappable_with_details::__do_is_nothrow_swappable_with_impl
-    {
-      typedef decltype(__test<_Tp, _Up>(0)) type;
-    };
-
-
-  template<typename _Tp>
-    struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
-    : public __swappable_details::__do_is_nothrow_swappable_impl
-    {
-      typedef decltype(__test<_Tp&>(0)) type;
-    };
-
-
-  template<typename _Tp, typename _Up>
-    struct is_swappable_with
-    : public __is_swappable_with_impl<_Tp, _Up>::type
-    { };
-
-
-  template<typename _Tp, typename _Up>
-    struct is_nothrow_swappable_with
-    : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
-    { };
-
-
-
-  template<typename _Tp, typename _Up>
-    constexpr bool is_swappable_with_v =
-      is_swappable_with<_Tp, _Up>::value;
-
-
-  template<typename _Tp, typename _Up>
-    constexpr bool is_nothrow_swappable_with_v =
-      is_nothrow_swappable_with<_Tp, _Up>::value;
-
-
-
-
-
-
-  template<typename _Result, typename _Ret, typename = void>
-    struct __is_invocable_impl : false_type { };
-
-  template<typename _Result, typename _Ret>
-    struct __is_invocable_impl<_Result, _Ret, __void_t<typename _Result::type>>
-    : __or_<is_void<_Ret>, is_convertible<typename _Result::type, _Ret>>::type
-    { };
-
-  template<typename _Fn, typename... _ArgTypes>
-    struct __is_invocable
-    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
-    { };
-
-  template<typename _Fn, typename _Tp, typename... _Args>
-    constexpr bool __call_is_nt(__invoke_memfun_ref)
-    {
-      using _Up = typename __inv_unwrap<_Tp>::type;
-      return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
-     std::declval<_Args>()...));
-    }
-
-  template<typename _Fn, typename _Tp, typename... _Args>
-    constexpr bool __call_is_nt(__invoke_memfun_deref)
-    {
-      return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
-     std::declval<_Args>()...));
-    }
-
-  template<typename _Fn, typename _Tp>
-    constexpr bool __call_is_nt(__invoke_memobj_ref)
-    {
-      using _Up = typename __inv_unwrap<_Tp>::type;
-      return noexcept(std::declval<_Up>().*std::declval<_Fn>());
-    }
-
-  template<typename _Fn, typename _Tp>
-    constexpr bool __call_is_nt(__invoke_memobj_deref)
-    {
-      return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
-    }
-
-  template<typename _Fn, typename... _Args>
-    constexpr bool __call_is_nt(__invoke_other)
-    {
-      return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
-    }
-
-  template<typename _Result, typename _Fn, typename... _Args>
-    struct __call_is_nothrow
-    : __bool_constant<
- std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
-      >
-    { };
-
-  template<typename _Fn, typename... _Args>
-    using __call_is_nothrow_
-      = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
-
-
-  template<typename _Fn, typename... _Args>
-    struct __is_nothrow_invocable
-    : __and_<__is_invocable<_Fn, _Args...>,
-             __call_is_nothrow_<_Fn, _Args...>>::type
-    { };
-
-  struct __nonesuch {
-    __nonesuch() = delete;
-    ~__nonesuch() = delete;
-    __nonesuch(__nonesuch const&) = delete;
-    void operator=(__nonesuch const&) = delete;
-  };
-# 2947 "../x86_64-pc-linux-gnu/libstdc++-v3/include/type_traits" 3
-
-}
-# 2 "/tmp/test.C" 2
-
-
-# 3 "/tmp/test.C"
-template <typename T, typename S>
-struct dummy{
- typedef std::is_nothrow_default_constructible<T> dc;
- void fu()noexcept(dc::value){}
-};
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/set" 1
-# 58 "../x86_64-pc-linux-gnu/libstdc++-v3/include/set"
-       
-# 59 "../x86_64-pc-linux-gnu/libstdc++-v3/include/set" 3
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 1 3
-# 61 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-       
-# 62 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 1 3
-# 60 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/functexcept.h" 1 3
-# 40 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/functexcept.h" 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception_defines.h" 1 3
-# 41 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/functexcept.h" 2 3
-
-
-# 42 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/functexcept.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  void
-  __throw_bad_exception(void) __attribute__((__noreturn__));
-
-
-  void
-  __throw_bad_alloc(void) __attribute__((__noreturn__));
-
-
-  void
-  __throw_bad_cast(void) __attribute__((__noreturn__));
-
-  void
-  __throw_bad_typeid(void) __attribute__((__noreturn__));
-
-
-  void
-  __throw_logic_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_domain_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_invalid_argument(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_length_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_out_of_range(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__))
-    __attribute__((__format__(__gnu_printf__, 1, 2)));
-
-  void
-  __throw_runtime_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_range_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_overflow_error(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_underflow_error(const char*) __attribute__((__noreturn__));
-
-
-  void
-  __throw_ios_failure(const char*) __attribute__((__noreturn__));
-
-  void
-  __throw_system_error(int) __attribute__((__noreturn__));
-
-  void
-  __throw_future_error(int) __attribute__((__noreturn__));
-
-
-  void
-  __throw_bad_function_call() __attribute__((__noreturn__));
-
-
-}
-# 61 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cpp_type_traits.h" 1 3
-# 35 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cpp_type_traits.h" 3
-       
-# 36 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cpp_type_traits.h" 3
-# 67 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cpp_type_traits.h" 3
-extern "C++" {
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  struct __true_type { };
-  struct __false_type { };
-
-  template<bool>
-    struct __truth_type
-    { typedef __false_type __type; };
-
-  template<>
-    struct __truth_type<true>
-    { typedef __true_type __type; };
-
-
-
-  template<class _Sp, class _Tp>
-    struct __traitor
-    {
-      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
-      typedef typename __truth_type<__value>::__type __type;
-    };
-
-
-  template<typename, typename>
-    struct __are_same
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-  template<typename _Tp>
-    struct __are_same<_Tp, _Tp>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-  template<typename _Tp>
-    struct __is_void
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-  template<>
-    struct __is_void<void>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-
-
-  template<typename _Tp>
-    struct __is_integer
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-
-
-
-
-  template<>
-    struct __is_integer<bool>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<signed char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<unsigned char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-  template<>
-    struct __is_integer<wchar_t>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-
-  template<>
-    struct __is_integer<char16_t>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<char32_t>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-  template<>
-    struct __is_integer<short>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<unsigned short>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<int>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<unsigned int>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<long>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<unsigned long>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<long long>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_integer<unsigned long long>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-# 261 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cpp_type_traits.h" 3
-template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer<unsigned __int128> { enum { __value = 1 }; typedef __true_type __type; };
-# 278 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cpp_type_traits.h" 3
-  template<typename _Tp>
-    struct __is_floating
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-
-  template<>
-    struct __is_floating<float>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_floating<double>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_floating<long double>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-
-
-  template<typename _Tp>
-    struct __is_pointer
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-  template<typename _Tp>
-    struct __is_pointer<_Tp*>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-
-
-  template<typename _Tp>
-    struct __is_arithmetic
-    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
-    { };
-
-
-
-
-  template<typename _Tp>
-    struct __is_scalar
-    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
-    { };
-
-
-
-
-  template<typename _Tp>
-    struct __is_char
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-  template<>
-    struct __is_char<char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-  template<>
-    struct __is_char<wchar_t>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-  template<typename _Tp>
-    struct __is_byte
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-  template<>
-    struct __is_byte<char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_byte<signed char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<>
-    struct __is_byte<unsigned char>
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-
-
-
-  template<typename _Tp>
-    struct __is_move_iterator
-    {
-      enum { __value = 0 };
-      typedef __false_type __type;
-    };
-
-
-
-  template<typename _Iterator>
-    inline _Iterator
-    __miter_base(_Iterator __it)
-    { return __it; }
-
-
-}
-}
-# 62 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/type_traits.h" 1 3
-# 32 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/type_traits.h" 3
-       
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/type_traits.h" 3
-
-
-
-
-extern "C++" {
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  template<bool, typename>
-    struct __enable_if
-    { };
-
-  template<typename _Tp>
-    struct __enable_if<true, _Tp>
-    { typedef _Tp __type; };
-
-
-
-  template<bool _Cond, typename _Iftrue, typename _Iffalse>
-    struct __conditional_type
-    { typedef _Iftrue __type; };
-
-  template<typename _Iftrue, typename _Iffalse>
-    struct __conditional_type<false, _Iftrue, _Iffalse>
-    { typedef _Iffalse __type; };
-
-
-
-  template<typename _Tp>
-    struct __add_unsigned
-    {
-    private:
-      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
-
-    public:
-      typedef typename __if_type::__type __type;
-    };
-
-  template<>
-    struct __add_unsigned<char>
-    { typedef unsigned char __type; };
-
-  template<>
-    struct __add_unsigned<signed char>
-    { typedef unsigned char __type; };
-
-  template<>
-    struct __add_unsigned<short>
-    { typedef unsigned short __type; };
-
-  template<>
-    struct __add_unsigned<int>
-    { typedef unsigned int __type; };
-
-  template<>
-    struct __add_unsigned<long>
-    { typedef unsigned long __type; };
-
-  template<>
-    struct __add_unsigned<long long>
-    { typedef unsigned long long __type; };
-
-
-  template<>
-    struct __add_unsigned<bool>;
-
-  template<>
-    struct __add_unsigned<wchar_t>;
-
-
-
-  template<typename _Tp>
-    struct __remove_unsigned
-    {
-    private:
-      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
-
-    public:
-      typedef typename __if_type::__type __type;
-    };
-
-  template<>
-    struct __remove_unsigned<char>
-    { typedef signed char __type; };
-
-  template<>
-    struct __remove_unsigned<unsigned char>
-    { typedef signed char __type; };
-
-  template<>
-    struct __remove_unsigned<unsigned short>
-    { typedef short __type; };
-
-  template<>
-    struct __remove_unsigned<unsigned int>
-    { typedef int __type; };
-
-  template<>
-    struct __remove_unsigned<unsigned long>
-    { typedef long __type; };
-
-  template<>
-    struct __remove_unsigned<unsigned long long>
-    { typedef long long __type; };
-
-
-  template<>
-    struct __remove_unsigned<bool>;
-
-  template<>
-    struct __remove_unsigned<wchar_t>;
-
-
-
-  template<typename _Type>
-    inline bool
-    __is_null_pointer(_Type* __ptr)
-    { return __ptr == 0; }
-
-  template<typename _Type>
-    inline bool
-    __is_null_pointer(_Type)
-    { return false; }
-
-
-  inline bool
-  __is_null_pointer(std::nullptr_t)
-  { return true; }
-
-
-
-  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
-    struct __promote
-    { typedef double __type; };
-
-
-
-
-  template<typename _Tp>
-    struct __promote<_Tp, false>
-    { };
-
-  template<>
-    struct __promote<long double>
-    { typedef long double __type; };
-
-  template<>
-    struct __promote<double>
-    { typedef double __type; };
-
-  template<>
-    struct __promote<float>
-    { typedef float __type; };
-
-  template<typename _Tp, typename _Up,
-           typename _Tp2 = typename __promote<_Tp>::__type,
-           typename _Up2 = typename __promote<_Up>::__type>
-    struct __promote_2
-    {
-      typedef __typeof__(_Tp2() + _Up2()) __type;
-    };
-
-  template<typename _Tp, typename _Up, typename _Vp,
-           typename _Tp2 = typename __promote<_Tp>::__type,
-           typename _Up2 = typename __promote<_Up>::__type,
-           typename _Vp2 = typename __promote<_Vp>::__type>
-    struct __promote_3
-    {
-      typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
-    };
-
-  template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
-           typename _Tp2 = typename __promote<_Tp>::__type,
-           typename _Up2 = typename __promote<_Up>::__type,
-           typename _Vp2 = typename __promote<_Vp>::__type,
-           typename _Wp2 = typename __promote<_Wp>::__type>
-    struct __promote_4
-    {
-      typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
-    };
-
-
-}
-}
-# 63 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/numeric_traits.h" 1 3
-# 32 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/numeric_traits.h" 3
-       
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/numeric_traits.h" 3
-
-
-
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-# 54 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/numeric_traits.h" 3
-  template<typename _Value>
-    struct __numeric_traits_integer
-    {
-
-      static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
-      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
-
-
-
-      static const bool __is_signed = ((_Value)(-1) < 0);
-      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
-    };
-
-  template<typename _Value>
-    const _Value __numeric_traits_integer<_Value>::__min;
-
-  template<typename _Value>
-    const _Value __numeric_traits_integer<_Value>::__max;
-
-  template<typename _Value>
-    const bool __numeric_traits_integer<_Value>::__is_signed;
-
-  template<typename _Value>
-    const int __numeric_traits_integer<_Value>::__digits;
-# 99 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/numeric_traits.h" 3
-  template<typename _Value>
-    struct __numeric_traits_floating
-    {
-
-      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
-
-
-      static const bool __is_signed = true;
-      static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
-      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
-    };
-
-  template<typename _Value>
-    const int __numeric_traits_floating<_Value>::__max_digits10;
-
-  template<typename _Value>
-    const bool __numeric_traits_floating<_Value>::__is_signed;
-
-  template<typename _Value>
-    const int __numeric_traits_floating<_Value>::__digits10;
-
-  template<typename _Value>
-    const int __numeric_traits_floating<_Value>::__max_exponent10;
-
-  template<typename _Value>
-    struct __numeric_traits
-    : public __conditional_type<std::__is_integer<_Value>::__value,
-    __numeric_traits_integer<_Value>,
-    __numeric_traits_floating<_Value> >::__type
-    { };
-
-
-}
-# 64 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_pair.h" 1 3
-# 59 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_pair.h" 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/move.h" 1 3
-# 34 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/move.h" 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/concept_check.h" 1 3
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/concept_check.h" 3
-       
-# 34 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/concept_check.h" 3
-# 35 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/move.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-  template<typename _Tp>
-    inline constexpr _Tp*
-    __addressof(_Tp& __r) noexcept
-    { return __builtin_addressof(__r); }
-
-
-
-
-}
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-# 72 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/move.h" 3
-  template<typename _Tp>
-    constexpr _Tp&&
-    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
-    { return static_cast<_Tp&&>(__t); }
-
-
-
-
-
-
-
-  template<typename _Tp>
-    constexpr _Tp&&
-    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
-    {
-      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
-      " substituting _Tp is an lvalue reference type");
-      return static_cast<_Tp&&>(__t);
-    }
-
-
-
-
-
-
-  template<typename _Tp>
-    constexpr typename std::remove_reference<_Tp>::type&&
-    move(_Tp&& __t) noexcept
-    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
-
-
-  template<typename _Tp>
-    struct __move_if_noexcept_cond
-    : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
-                    is_copy_constructible<_Tp>>::type { };
-# 116 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/move.h" 3
-  template<typename _Tp>
-    constexpr typename
-    conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
-    move_if_noexcept(_Tp& __x) noexcept
-    { return std::move(__x); }
-# 136 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/move.h" 3
-  template<typename _Tp>
-    inline _Tp*
-    addressof(_Tp& __r) noexcept
-    { return std::__addressof(__r); }
-
-
-
-  template<typename _Tp>
-    const _Tp* addressof(const _Tp&&) = delete;
-
-
-  template <typename _Tp, typename _Up = _Tp>
-    inline _Tp
-    __exchange(_Tp& __obj, _Up&& __new_val)
-    {
-      _Tp __old_val = std::move(__obj);
-      __obj = std::forward<_Up>(__new_val);
-      return __old_val;
-    }
-# 176 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/move.h" 3
-  template<typename _Tp>
-    inline
-
-    typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
-         is_move_constructible<_Tp>,
-         is_move_assignable<_Tp>>::value>::type
-    swap(_Tp& __a, _Tp& __b)
-    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
-             is_nothrow_move_assignable<_Tp>>::value)
-
-
-
-
-    {
-
-     
-
-      _Tp __tmp = std::move(__a);
-      __a = std::move(__b);
-      __b = std::move(__tmp);
-    }
-
-
-
-
-  template<typename _Tp, size_t _Nm>
-    inline
-
-    typename enable_if<__is_swappable<_Tp>::value>::type
-    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
-    noexcept(__is_nothrow_swappable<_Tp>::value)
-
-
-
-
-    {
-      for (size_t __n = 0; __n < _Nm; ++__n)
- swap(__a[__n], __b[__n]);
-    }
-
-
-
-}
-# 60 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_pair.h" 2 3
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-# 76 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_pair.h" 3
-  struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
-
-
-  constexpr piecewise_construct_t piecewise_construct =
-    piecewise_construct_t();
-
-
-  template<typename...>
-    class tuple;
-
-  template<std::size_t...>
-    struct _Index_tuple;
-
-
-
-
-
-
-  template <bool, typename _T1, typename _T2>
-    struct _PCC
-    {
-      template <typename _U1, typename _U2>
-      static constexpr bool _ConstructiblePair()
-      {
- return __and_<is_constructible<_T1, const _U1&>,
-        is_constructible<_T2, const _U2&>>::value;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _ImplicitlyConvertiblePair()
-      {
- return __and_<is_convertible<const _U1&, _T1>,
-        is_convertible<const _U2&, _T2>>::value;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _MoveConstructiblePair()
-      {
- return __and_<is_constructible<_T1, _U1&&>,
-        is_constructible<_T2, _U2&&>>::value;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _ImplicitlyMoveConvertiblePair()
-      {
- return __and_<is_convertible<_U1&&, _T1>,
-        is_convertible<_U2&&, _T2>>::value;
-      }
-
-      template <bool __implicit, typename _U1, typename _U2>
-      static constexpr bool _CopyMovePair()
-      {
- using __do_converts = __and_<is_convertible<const _U1&, _T1>,
-      is_convertible<_U2&&, _T2>>;
- using __converts = typename conditional<__implicit,
-           __do_converts,
-           __not_<__do_converts>>::type;
- return __and_<is_constructible<_T1, const _U1&>,
-        is_constructible<_T2, _U2&&>,
-        __converts
-        >::value;
-      }
-
-      template <bool __implicit, typename _U1, typename _U2>
-      static constexpr bool _MoveCopyPair()
-      {
- using __do_converts = __and_<is_convertible<_U1&&, _T1>,
-      is_convertible<const _U2&, _T2>>;
- using __converts = typename conditional<__implicit,
-           __do_converts,
-           __not_<__do_converts>>::type;
- return __and_<is_constructible<_T1, _U1&&>,
-        is_constructible<_T2, const _U2&&>,
-        __converts
-        >::value;
-      }
-  };
-
-  template <typename _T1, typename _T2>
-    struct _PCC<false, _T1, _T2>
-    {
-      template <typename _U1, typename _U2>
-      static constexpr bool _ConstructiblePair()
-      {
- return false;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _ImplicitlyConvertiblePair()
-      {
- return false;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _MoveConstructiblePair()
-      {
- return false;
-      }
-
-      template <typename _U1, typename _U2>
-      static constexpr bool _ImplicitlyMoveConvertiblePair()
-      {
- return false;
-      }
-  };
-
-
-
-
-  struct __nonesuch_no_braces : std::__nonesuch {
-    explicit __nonesuch_no_braces(const __nonesuch&) = delete;
-  };
-# 197 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_pair.h" 3
-  template<typename _T1, typename _T2>
-    struct pair
-    {
-      typedef _T1 first_type;
-      typedef _T2 second_type;
-
-      _T1 first;
-      _T2 second;
-
-
-
-
-
-
-      template <typename _U1 = _T1,
-                typename _U2 = _T2,
-                typename enable_if<__and_<
-                                     __is_implicitly_default_constructible<_U1>,
-                                     __is_implicitly_default_constructible<_U2>>
-                                   ::value, bool>::type = true>
-
-      constexpr pair()
-      : first(), second() { }
-
-
-      template <typename _U1 = _T1,
-                typename _U2 = _T2,
-                typename enable_if<__and_<
-                       is_default_constructible<_U1>,
-                       is_default_constructible<_U2>,
-                       __not_<
-                         __and_<__is_implicitly_default_constructible<_U1>,
-                                __is_implicitly_default_constructible<_U2>>>>
-                                   ::value, bool>::type = false>
-      explicit constexpr pair()
-      : first(), second() { }
-# 241 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_pair.h" 3
-      using _PCCP = _PCC<true, _T1, _T2>;
-
-      template<typename _U1 = _T1, typename _U2=_T2, typename
-        enable_if<_PCCP::template
-      _ConstructiblePair<_U1, _U2>()
-                  && _PCCP::template
-      _ImplicitlyConvertiblePair<_U1, _U2>(),
-                         bool>::type=true>
-      constexpr pair(const _T1& __a, const _T2& __b)
-      : first(__a), second(__b) { }
-
-       template<typename _U1 = _T1, typename _U2=_T2, typename
-  enable_if<_PCCP::template
-       _ConstructiblePair<_U1, _U2>()
-                   && !_PCCP::template
-       _ImplicitlyConvertiblePair<_U1, _U2>(),
-                         bool>::type=false>
-      explicit constexpr pair(const _T1& __a, const _T2& __b)
-      : first(__a), second(__b) { }
-# 269 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_pair.h" 3
-      template <typename _U1, typename _U2>
-        using _PCCFP = _PCC<!is_same<_T1, _U1>::value
-       || !is_same<_T2, _U2>::value,
-       _T1, _T2>;
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCFP<_U1, _U2>::template
-      _ConstructiblePair<_U1, _U2>()
-                  && _PCCFP<_U1, _U2>::template
-      _ImplicitlyConvertiblePair<_U1, _U2>(),
-     bool>::type=true>
-        constexpr pair(const pair<_U1, _U2>& __p)
-        : first(__p.first), second(__p.second) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCFP<_U1, _U2>::template
-      _ConstructiblePair<_U1, _U2>()
-    && !_PCCFP<_U1, _U2>::template
-      _ImplicitlyConvertiblePair<_U1, _U2>(),
-                         bool>::type=false>
- explicit constexpr pair(const pair<_U1, _U2>& __p)
- : first(__p.first), second(__p.second) { }
-
-      constexpr pair(const pair&) = default;
-      constexpr pair(pair&&) = default;
-
-
-      template<typename _U1, typename
-        enable_if<_PCCP::template
-      _MoveCopyPair<true, _U1, _T2>(),
-                         bool>::type=true>
-       constexpr pair(_U1&& __x, const _T2& __y)
-       : first(std::forward<_U1>(__x)), second(__y) { }
-
-      template<typename _U1, typename
-        enable_if<_PCCP::template
-      _MoveCopyPair<false, _U1, _T2>(),
-                         bool>::type=false>
-       explicit constexpr pair(_U1&& __x, const _T2& __y)
-       : first(std::forward<_U1>(__x)), second(__y) { }
-
-      template<typename _U2, typename
-        enable_if<_PCCP::template
-      _CopyMovePair<true, _T1, _U2>(),
-                         bool>::type=true>
-       constexpr pair(const _T1& __x, _U2&& __y)
-       : first(__x), second(std::forward<_U2>(__y)) { }
-
-      template<typename _U2, typename
-        enable_if<_PCCP::template
-      _CopyMovePair<false, _T1, _U2>(),
-                         bool>::type=false>
-       explicit pair(const _T1& __x, _U2&& __y)
-       : first(__x), second(std::forward<_U2>(__y)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCP::template
-      _MoveConstructiblePair<_U1, _U2>()
-     && _PCCP::template
-      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
-                         bool>::type=true>
- constexpr pair(_U1&& __x, _U2&& __y)
- : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCP::template
-      _MoveConstructiblePair<_U1, _U2>()
-     && !_PCCP::template
-      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
-                         bool>::type=false>
- explicit constexpr pair(_U1&& __x, _U2&& __y)
- : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
-
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCFP<_U1, _U2>::template
-      _MoveConstructiblePair<_U1, _U2>()
-     && _PCCFP<_U1, _U2>::template
-      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
-                         bool>::type=true>
- constexpr pair(pair<_U1, _U2>&& __p)
- : first(std::forward<_U1>(__p.first)),
-   second(std::forward<_U2>(__p.second)) { }
-
-      template<typename _U1, typename _U2, typename
-        enable_if<_PCCFP<_U1, _U2>::template
-      _MoveConstructiblePair<_U1, _U2>()
-     && !_PCCFP<_U1, _U2>::template
-      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
-                         bool>::type=false>
- explicit constexpr pair(pair<_U1, _U2>&& __p)
- : first(std::forward<_U1>(__p.first)),
-   second(std::forward<_U2>(__p.second)) { }
-
-      template<typename... _Args1, typename... _Args2>
-        pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
-
-      pair&
-      operator=(typename conditional<
-  __and_<is_copy_assignable<_T1>,
-         is_copy_assignable<_T2>>::value,
-  const pair&, const __nonesuch_no_braces&>::type __p)
-      {
- first = __p.first;
- second = __p.second;
- return *this;
-      }
-
-      pair&
-      operator=(typename conditional<
-  __not_<__and_<is_copy_assignable<_T1>,
-                is_copy_assignable<_T2>>>::value,
-  const pair&, const __nonesuch_no_braces&>::type __p) = delete;
-
-      pair&
-      operator=(typename conditional<
-  __and_<is_move_assignable<_T1>,
-         is_move_assignable<_T2>>::value,
-  pair&&, __nonesuch_no_braces&&>::type __p)
-      noexcept(__and_<is_nothrow_move_assignable<_T1>,
-               is_nothrow_move_assignable<_T2>>::value)
-      {
- first = std::forward<first_type>(__p.first);
- second = std::forward<second_type>(__p.second);
- return *this;
-      }
-
-      template<typename _U1, typename _U2>
-      typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
-    is_assignable<_T2&, const _U2&>>::value,
-    pair&>::type
- operator=(const pair<_U1, _U2>& __p)
- {
-   first = __p.first;
-   second = __p.second;
-   return *this;
- }
-
-      template<typename _U1, typename _U2>
-      typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
-    is_assignable<_T2&, _U2&&>>::value,
-    pair&>::type
- operator=(pair<_U1, _U2>&& __p)
- {
-   first = std::forward<_U1>(__p.first);
-   second = std::forward<_U2>(__p.second);
-   return *this;
- }
-
-      void
-      swap(pair& __p)
-      noexcept(__and_<__is_nothrow_swappable<_T1>,
-                      __is_nothrow_swappable<_T2>>::value)
-      {
- using std::swap;
- swap(first, __p.first);
- swap(second, __p.second);
-      }
-
-    private:
-      template<typename... _Args1, std::size_t... _Indexes1,
-               typename... _Args2, std::size_t... _Indexes2>
-        pair(tuple<_Args1...>&, tuple<_Args2...>&,
-             _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
-
-    };
-
-
-
-
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return __x.first == __y.first && __x.second == __y.second; }
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return __x.first < __y.first
-      || (!(__y.first < __x.first) && __x.second < __y.second); }
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return !(__x == __y); }
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return __y < __x; }
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return !(__y < __x); }
-
-
-  template<typename _T1, typename _T2>
-    inline constexpr bool
-    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    { return !(__x < __y); }
-
-
-
-
-
-  template<typename _T1, typename _T2>
-    inline
-
-
-    typename enable_if<__and_<__is_swappable<_T1>,
-                              __is_swappable<_T2>>::value>::type
-
-
-
-    swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
-    noexcept(noexcept(__x.swap(__y)))
-    { __x.swap(__y); }
-
-
-  template<typename _T1, typename _T2>
-    typename enable_if<!__and_<__is_swappable<_T1>,
-          __is_swappable<_T2>>::value>::type
-    swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
-# 516 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_pair.h" 3
-  template<typename _T1, typename _T2>
-    constexpr pair<typename __decay_and_strip<_T1>::__type,
-                   typename __decay_and_strip<_T2>::__type>
-    make_pair(_T1&& __x, _T2&& __y)
-    {
-      typedef typename __decay_and_strip<_T1>::__type __ds_type1;
-      typedef typename __decay_and_strip<_T2>::__type __ds_type2;
-      typedef pair<__ds_type1, __ds_type2> __pair_type;
-      return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
-    }
-# 535 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_pair.h" 3
-
-}
-# 65 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_types.h" 1 3
-# 62 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_types.h" 3
-       
-# 63 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_types.h" 3
-
-
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-# 89 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_types.h" 3
-  struct input_iterator_tag { };
-
-
-  struct output_iterator_tag { };
-
-
-  struct forward_iterator_tag : public input_iterator_tag { };
-
-
-
-  struct bidirectional_iterator_tag : public forward_iterator_tag { };
-
-
-
-  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
-# 116 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_types.h" 3
-  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
-           typename _Pointer = _Tp*, typename _Reference = _Tp&>
-    struct iterator
-    {
-
-      typedef _Category iterator_category;
-
-      typedef _Tp value_type;
-
-      typedef _Distance difference_type;
-
-      typedef _Pointer pointer;
-
-      typedef _Reference reference;
-    };
-# 143 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_types.h" 3
-  template<typename _Iterator, typename = __void_t<>>
-    struct __iterator_traits { };
-
-  template<typename _Iterator>
-    struct __iterator_traits<_Iterator,
-        __void_t<typename _Iterator::iterator_category,
-          typename _Iterator::value_type,
-          typename _Iterator::difference_type,
-          typename _Iterator::pointer,
-          typename _Iterator::reference>>
-    {
-      typedef typename _Iterator::iterator_category iterator_category;
-      typedef typename _Iterator::value_type value_type;
-      typedef typename _Iterator::difference_type difference_type;
-      typedef typename _Iterator::pointer pointer;
-      typedef typename _Iterator::reference reference;
-    };
-
-  template<typename _Iterator>
-    struct iterator_traits
-    : public __iterator_traits<_Iterator> { };
-# 177 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_types.h" 3
-  template<typename _Tp>
-    struct iterator_traits<_Tp*>
-    {
-      typedef random_access_iterator_tag iterator_category;
-      typedef _Tp value_type;
-      typedef ptrdiff_t difference_type;
-      typedef _Tp* pointer;
-      typedef _Tp& reference;
-    };
-
-
-  template<typename _Tp>
-    struct iterator_traits<const _Tp*>
-    {
-      typedef random_access_iterator_tag iterator_category;
-      typedef _Tp value_type;
-      typedef ptrdiff_t difference_type;
-      typedef const _Tp* pointer;
-      typedef const _Tp& reference;
-    };
-
-
-
-
-
-  template<typename _Iter>
-    inline constexpr
-    typename iterator_traits<_Iter>::iterator_category
-    __iterator_category(const _Iter&)
-    { return typename iterator_traits<_Iter>::iterator_category(); }
-# 231 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_types.h" 3
-  template<typename _InIter>
-    using _RequireInputIter = typename
-      enable_if<is_convertible<typename
-  iterator_traits<_InIter>::iterator_category,
-          input_iterator_tag>::value>::type;
-
-
-
-}
-# 66 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_funcs.h" 1 3
-# 62 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_funcs.h" 3
-       
-# 63 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_funcs.h" 3
-
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/debug/assertions.h" 1 3
-# 66 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_funcs.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-  template <typename> struct _List_iterator;
-  template <typename> struct _List_const_iterator;
-
-
-  template<typename _InputIterator>
-    inline constexpr
-    typename iterator_traits<_InputIterator>::difference_type
-    __distance(_InputIterator __first, _InputIterator __last,
-               input_iterator_tag)
-    {
-
-     
-
-      typename iterator_traits<_InputIterator>::difference_type __n = 0;
-      while (__first != __last)
- {
-   ++__first;
-   ++__n;
- }
-      return __n;
-    }
-
-  template<typename _RandomAccessIterator>
-    inline constexpr
-    typename iterator_traits<_RandomAccessIterator>::difference_type
-    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
-               random_access_iterator_tag)
-    {
-
-     
-
-      return __last - __first;
-    }
-
-
-
-  template<typename _Tp>
-    ptrdiff_t
-    __distance(std::_List_iterator<_Tp>,
-        std::_List_iterator<_Tp>,
-        input_iterator_tag);
-
-  template<typename _Tp>
-    ptrdiff_t
-    __distance(std::_List_const_iterator<_Tp>,
-        std::_List_const_iterator<_Tp>,
-        input_iterator_tag);
-# 135 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_funcs.h" 3
-  template<typename _InputIterator>
-    inline
-    typename iterator_traits<_InputIterator>::difference_type
-    distance(_InputIterator __first, _InputIterator __last)
-    {
-
-      return std::__distance(__first, __last,
-        std::__iterator_category(__first));
-    }
-
-  template<typename _InputIterator, typename _Distance>
-    inline constexpr void
-    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
-    {
-
-     
-      ;
-      while (__n--)
- ++__i;
-    }
-
-  template<typename _BidirectionalIterator, typename _Distance>
-    inline constexpr void
-    __advance(_BidirectionalIterator& __i, _Distance __n,
-       bidirectional_iterator_tag)
-    {
-
-     
-
-      if (__n > 0)
-        while (__n--)
-   ++__i;
-      else
-        while (__n++)
-   --__i;
-    }
-
-  template<typename _RandomAccessIterator, typename _Distance>
-    inline constexpr void
-    __advance(_RandomAccessIterator& __i, _Distance __n,
-              random_access_iterator_tag)
-    {
-
-     
-
-      if (__builtin_constant_p(__n) && __n == 1)
- ++__i;
-      else if (__builtin_constant_p(__n) && __n == -1)
- --__i;
-      else
- __i += __n;
-    }
-# 200 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator_base_funcs.h" 3
-  template<typename _InputIterator, typename _Distance>
-    inline void
-    advance(_InputIterator& __i, _Distance __n)
-    {
-
-      typename iterator_traits<_InputIterator>::difference_type __d = __n;
-      std::__advance(__i, __d, std::__iterator_category(__i));
-    }
-
-
-
-  template<typename _InputIterator>
-    inline _InputIterator
-    next(_InputIterator __x, typename
-  iterator_traits<_InputIterator>::difference_type __n = 1)
-    {
-
-     
-      std::advance(__x, __n);
-      return __x;
-    }
-
-  template<typename _BidirectionalIterator>
-    inline _BidirectionalIterator
-    prev(_BidirectionalIterator __x, typename
-  iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
-    {
-
-     
-
-      std::advance(__x, -__n);
-      return __x;
-    }
-
-
-
-
-}
-# 67 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 1 3
-# 66 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/ptr_traits.h" 1 3
-# 37 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/ptr_traits.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  class __undefined;
-
-
-  template<typename _Tp>
-    struct __get_first_arg
-    { using type = __undefined; };
-
-  template<template<typename, typename...> class _Template, typename _Tp,
-           typename... _Types>
-    struct __get_first_arg<_Template<_Tp, _Types...>>
-    { using type = _Tp; };
-
-  template<typename _Tp>
-    using __get_first_arg_t = typename __get_first_arg<_Tp>::type;
-
-
-  template<typename _Tp, typename _Up>
-    struct __replace_first_arg
-    { };
-
-  template<template<typename, typename...> class _Template, typename _Up,
-           typename _Tp, typename... _Types>
-    struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
-    { using type = _Template<_Up, _Types...>; };
-
-  template<typename _Tp, typename _Up>
-    using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;
-
-  template<typename _Tp>
-    using __make_not_void
-      = typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
-
-
-
-
-
-  template<typename _Ptr>
-    struct pointer_traits
-    {
-    private:
-      template<typename _Tp>
- using __element_type = typename _Tp::element_type;
-
-      template<typename _Tp>
- using __difference_type = typename _Tp::difference_type;
-
-      template<typename _Tp, typename _Up, typename = void>
- struct __rebind : __replace_first_arg<_Tp, _Up> { };
-
-      template<typename _Tp, typename _Up>
- struct __rebind<_Tp, _Up, __void_t<typename _Tp::template rebind<_Up>>>
- { using type = typename _Tp::template rebind<_Up>; };
-
-    public:
-
-      using pointer = _Ptr;
-
-
-      using element_type
- = __detected_or_t<__get_first_arg_t<_Ptr>, __element_type, _Ptr>;
-
-
-      using difference_type
- = __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;
-
-
-      template<typename _Up>
-        using rebind = typename __rebind<_Ptr, _Up>::type;
-
-      static _Ptr
-      pointer_to(__make_not_void<element_type>& __e)
-      { return _Ptr::pointer_to(__e); }
-
-      static_assert(!is_same<element_type, __undefined>::value,
-   "pointer type defines element_type or is like SomePointer<T, Args>");
-    };
-
-
-
-
-
-  template<typename _Tp>
-    struct pointer_traits<_Tp*>
-    {
-
-      typedef _Tp* pointer;
-
-      typedef _Tp element_type;
-
-      typedef ptrdiff_t difference_type;
-
-      template<typename _Up>
-        using rebind = _Up*;
-
-
-
-
-
-
-      static pointer
-      pointer_to(__make_not_void<element_type>& __r) noexcept
-      { return std::addressof(__r); }
-    };
-
-
-  template<typename _Ptr, typename _Tp>
-    using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;
-
-  template<typename _Tp>
-    constexpr _Tp*
-    __to_address(_Tp* __ptr) noexcept
-    {
-      static_assert(!std::is_function<_Tp>::value, "not a function pointer");
-      return __ptr;
-    }
-
-
-  template<typename _Ptr>
-    constexpr typename std::pointer_traits<_Ptr>::element_type*
-    __to_address(const _Ptr& __ptr)
-    { return std::__to_address(__ptr.operator->()); }
-# 198 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/ptr_traits.h" 3
-
-}
-# 67 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 2 3
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-# 100 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _Iterator>
-    class reverse_iterator
-    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
-        typename iterator_traits<_Iterator>::value_type,
-        typename iterator_traits<_Iterator>::difference_type,
-        typename iterator_traits<_Iterator>::pointer,
-                      typename iterator_traits<_Iterator>::reference>
-    {
-    protected:
-      _Iterator current;
-
-      typedef iterator_traits<_Iterator> __traits_type;
-
-    public:
-      typedef _Iterator iterator_type;
-      typedef typename __traits_type::difference_type difference_type;
-      typedef typename __traits_type::pointer pointer;
-      typedef typename __traits_type::reference reference;
-
-
-
-
-
-
-
-     
-      reverse_iterator() : current() { }
-
-
-
-
-      explicit
-      reverse_iterator(iterator_type __x) : current(__x) { }
-
-
-
-
-     
-      reverse_iterator(const reverse_iterator& __x)
-      : current(__x.current) { }
-
-
-
-
-
-      template<typename _Iter>
-
-        reverse_iterator(const reverse_iterator<_Iter>& __x)
- : current(__x.base()) { }
-
-
-
-
-      iterator_type
-      base() const
-      { return current; }
-# 167 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-      reference
-      operator*() const
-      {
- _Iterator __tmp = current;
- return *--__tmp;
-      }
-
-
-
-
-
-
-      pointer
-      operator->() const
-      { return &(operator*()); }
-
-
-
-
-
-
-      reverse_iterator&
-      operator++()
-      {
- --current;
- return *this;
-      }
-
-
-
-
-
-
-      reverse_iterator
-      operator++(int)
-      {
- reverse_iterator __tmp = *this;
- --current;
- return __tmp;
-      }
-
-
-
-
-
-
-      reverse_iterator&
-      operator--()
-      {
- ++current;
- return *this;
-      }
-
-
-
-
-
-
-      reverse_iterator
-      operator--(int)
-      {
- reverse_iterator __tmp = *this;
- ++current;
- return __tmp;
-      }
-
-
-
-
-
-
-      reverse_iterator
-      operator+(difference_type __n) const
-      { return reverse_iterator(current - __n); }
-
-
-
-
-
-
-
-      reverse_iterator&
-      operator+=(difference_type __n)
-      {
- current -= __n;
- return *this;
-      }
-
-
-
-
-
-
-      reverse_iterator
-      operator-(difference_type __n) const
-      { return reverse_iterator(current + __n); }
-
-
-
-
-
-
-
-      reverse_iterator&
-      operator-=(difference_type __n)
-      {
- current += __n;
- return *this;
-      }
-
-
-
-
-
-
-      reference
-      operator[](difference_type __n) const
-      { return *(*this + __n); }
-    };
-# 297 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _Iterator>
-    inline bool
-    operator==(const reverse_iterator<_Iterator>& __x,
-        const reverse_iterator<_Iterator>& __y)
-    { return __x.base() == __y.base(); }
-
-  template<typename _Iterator>
-    inline bool
-    operator<(const reverse_iterator<_Iterator>& __x,
-       const reverse_iterator<_Iterator>& __y)
-    { return __y.base() < __x.base(); }
-
-  template<typename _Iterator>
-    inline bool
-    operator!=(const reverse_iterator<_Iterator>& __x,
-        const reverse_iterator<_Iterator>& __y)
-    { return !(__x == __y); }
-
-  template<typename _Iterator>
-    inline bool
-    operator>(const reverse_iterator<_Iterator>& __x,
-       const reverse_iterator<_Iterator>& __y)
-    { return __y < __x; }
-
-  template<typename _Iterator>
-    inline bool
-    operator<=(const reverse_iterator<_Iterator>& __x,
-        const reverse_iterator<_Iterator>& __y)
-    { return !(__y < __x); }
-
-  template<typename _Iterator>
-    inline bool
-    operator>=(const reverse_iterator<_Iterator>& __x,
-        const reverse_iterator<_Iterator>& __y)
-    { return !(__x < __y); }
-
-
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator==(const reverse_iterator<_IteratorL>& __x,
-        const reverse_iterator<_IteratorR>& __y)
-    { return __x.base() == __y.base(); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator<(const reverse_iterator<_IteratorL>& __x,
-       const reverse_iterator<_IteratorR>& __y)
-    { return __y.base() < __x.base(); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator!=(const reverse_iterator<_IteratorL>& __x,
-        const reverse_iterator<_IteratorR>& __y)
-    { return !(__x == __y); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator>(const reverse_iterator<_IteratorL>& __x,
-       const reverse_iterator<_IteratorR>& __y)
-    { return __y < __x; }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator<=(const reverse_iterator<_IteratorL>& __x,
-        const reverse_iterator<_IteratorR>& __y)
-    { return !(__y < __x); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator>=(const reverse_iterator<_IteratorL>& __x,
-        const reverse_iterator<_IteratorR>& __y)
-    { return !(__x < __y); }
-# 387 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _IteratorL, typename _IteratorR>
-    inline auto
-    operator-(const reverse_iterator<_IteratorL>& __x,
-       const reverse_iterator<_IteratorR>& __y)
-    -> decltype(__y.base() - __x.base())
-    { return __y.base() - __x.base(); }
-
-
-  template<typename _Iterator>
-    inline reverse_iterator<_Iterator>
-    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
-       const reverse_iterator<_Iterator>& __x)
-    { return reverse_iterator<_Iterator>(__x.base() - __n); }
-
-
-
-  template<typename _Iterator>
-    inline reverse_iterator<_Iterator>
-    __make_reverse_iterator(_Iterator __i)
-    { return reverse_iterator<_Iterator>(__i); }
-
-
-
-
-
-
-
-  template<typename _Iterator>
-    inline reverse_iterator<_Iterator>
-    make_reverse_iterator(_Iterator __i)
-    { return reverse_iterator<_Iterator>(__i); }
-
-
-
-
-  template<typename _Iterator>
-    auto
-    __niter_base(reverse_iterator<_Iterator> __it)
-    -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
-    { return __make_reverse_iterator(__niter_base(__it.base())); }
-
-  template<typename _Iterator>
-    struct __is_move_iterator<reverse_iterator<_Iterator> >
-      : __is_move_iterator<_Iterator>
-    { };
-
-  template<typename _Iterator>
-    auto
-    __miter_base(reverse_iterator<_Iterator> __it)
-    -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
-    { return __make_reverse_iterator(__miter_base(__it.base())); }
-# 451 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _Container>
-    class back_insert_iterator
-    : public iterator<output_iterator_tag, void, void, void, void>
-    {
-    protected:
-      _Container* container;
-
-    public:
-
-      typedef _Container container_type;
-
-
-      explicit
-      back_insert_iterator(_Container& __x)
-      : container(std::__addressof(__x)) { }
-# 486 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-      back_insert_iterator&
-      operator=(const typename _Container::value_type& __value)
-      {
- container->push_back(__value);
- return *this;
-      }
-
-      back_insert_iterator&
-      operator=(typename _Container::value_type&& __value)
-      {
- container->push_back(std::move(__value));
- return *this;
-      }
-
-
-
-      back_insert_iterator&
-      operator*()
-      { return *this; }
-
-
-      back_insert_iterator&
-      operator++()
-      { return *this; }
-
-
-      back_insert_iterator
-      operator++(int)
-      { return *this; }
-    };
-# 528 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _Container>
-    inline back_insert_iterator<_Container>
-    back_inserter(_Container& __x)
-    { return back_insert_iterator<_Container>(__x); }
-# 543 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _Container>
-    class front_insert_iterator
-    : public iterator<output_iterator_tag, void, void, void, void>
-    {
-    protected:
-      _Container* container;
-
-    public:
-
-      typedef _Container container_type;
-
-
-      explicit front_insert_iterator(_Container& __x)
-      : container(std::__addressof(__x)) { }
-# 577 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-      front_insert_iterator&
-      operator=(const typename _Container::value_type& __value)
-      {
- container->push_front(__value);
- return *this;
-      }
-
-      front_insert_iterator&
-      operator=(typename _Container::value_type&& __value)
-      {
- container->push_front(std::move(__value));
- return *this;
-      }
-
-
-
-      front_insert_iterator&
-      operator*()
-      { return *this; }
-
-
-      front_insert_iterator&
-      operator++()
-      { return *this; }
-
-
-      front_insert_iterator
-      operator++(int)
-      { return *this; }
-    };
-# 619 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _Container>
-    inline front_insert_iterator<_Container>
-    front_inserter(_Container& __x)
-    { return front_insert_iterator<_Container>(__x); }
-# 638 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _Container>
-    class insert_iterator
-    : public iterator<output_iterator_tag, void, void, void, void>
-    {
-    protected:
-      _Container* container;
-      typename _Container::iterator iter;
-
-    public:
-
-      typedef _Container container_type;
-
-
-
-
-
-      insert_iterator(_Container& __x, typename _Container::iterator __i)
-      : container(std::__addressof(__x)), iter(__i) {}
-# 689 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-      insert_iterator&
-      operator=(const typename _Container::value_type& __value)
-      {
- iter = container->insert(iter, __value);
- ++iter;
- return *this;
-      }
-
-      insert_iterator&
-      operator=(typename _Container::value_type&& __value)
-      {
- iter = container->insert(iter, std::move(__value));
- ++iter;
- return *this;
-      }
-
-
-
-      insert_iterator&
-      operator*()
-      { return *this; }
-
-
-      insert_iterator&
-      operator++()
-      { return *this; }
-
-
-      insert_iterator&
-      operator++(int)
-      { return *this; }
-    };
-# 734 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _Container, typename _Iterator>
-    inline insert_iterator<_Container>
-    inserter(_Container& __x, _Iterator __i)
-    {
-      return insert_iterator<_Container>(__x,
-      typename _Container::iterator(__i));
-    }
-
-
-
-
-}
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-# 758 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  using std::iterator_traits;
-  using std::iterator;
-  template<typename _Iterator, typename _Container>
-    class __normal_iterator
-    {
-    protected:
-      _Iterator _M_current;
-
-      typedef iterator_traits<_Iterator> __traits_type;
-
-    public:
-      typedef _Iterator iterator_type;
-      typedef typename __traits_type::iterator_category iterator_category;
-      typedef typename __traits_type::value_type value_type;
-      typedef typename __traits_type::difference_type difference_type;
-      typedef typename __traits_type::reference reference;
-      typedef typename __traits_type::pointer pointer;
-
-      constexpr __normal_iterator() noexcept
-      : _M_current(_Iterator()) { }
-
-      explicit
-      __normal_iterator(const _Iterator& __i) noexcept
-      : _M_current(__i) { }
-
-
-      template<typename _Iter>
-        __normal_iterator(const __normal_iterator<_Iter,
-     typename __enable_if<
-              (std::__are_same<_Iter, typename _Container::pointer>::__value),
-        _Container>::__type>& __i) noexcept
-        : _M_current(__i.base()) { }
-
-
-      reference
-      operator*() const noexcept
-      { return *_M_current; }
-
-      pointer
-      operator->() const noexcept
-      { return _M_current; }
-
-      __normal_iterator&
-      operator++() noexcept
-      {
- ++_M_current;
- return *this;
-      }
-
-      __normal_iterator
-      operator++(int) noexcept
-      { return __normal_iterator(_M_current++); }
-
-
-      __normal_iterator&
-      operator--() noexcept
-      {
- --_M_current;
- return *this;
-      }
-
-      __normal_iterator
-      operator--(int) noexcept
-      { return __normal_iterator(_M_current--); }
-
-
-      reference
-      operator[](difference_type __n) const noexcept
-      { return _M_current[__n]; }
-
-      __normal_iterator&
-      operator+=(difference_type __n) noexcept
-      { _M_current += __n; return *this; }
-
-      __normal_iterator
-      operator+(difference_type __n) const noexcept
-      { return __normal_iterator(_M_current + __n); }
-
-      __normal_iterator&
-      operator-=(difference_type __n) noexcept
-      { _M_current -= __n; return *this; }
-
-      __normal_iterator
-      operator-(difference_type __n) const noexcept
-      { return __normal_iterator(_M_current - __n); }
-
-      const _Iterator&
-      base() const noexcept
-      { return _M_current; }
-    };
-# 858 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
-        const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() == __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
-        const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() == __rhs.base(); }
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-        const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() != __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
-        const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() != __rhs.base(); }
-
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
-       const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() < __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
-       const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() < __rhs.base(); }
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
-       const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() > __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
-       const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() > __rhs.base(); }
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-        const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() <= __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
-        const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() <= __rhs.base(); }
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-    inline bool
-    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
-        const __normal_iterator<_IteratorR, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() >= __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline bool
-    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
-        const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() >= __rhs.base(); }
-
-
-
-
-
-  template<typename _IteratorL, typename _IteratorR, typename _Container>
-
-
-    inline auto
-    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
-       const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
-    -> decltype(__lhs.base() - __rhs.base())
-
-
-
-
-
-    { return __lhs.base() - __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline typename __normal_iterator<_Iterator, _Container>::difference_type
-    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
-       const __normal_iterator<_Iterator, _Container>& __rhs)
-    noexcept
-    { return __lhs.base() - __rhs.base(); }
-
-  template<typename _Iterator, typename _Container>
-    inline __normal_iterator<_Iterator, _Container>
-    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
-       __n, const __normal_iterator<_Iterator, _Container>& __i)
-    noexcept
-    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
-
-
-}
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  template<typename _Iterator, typename _Container>
-    _Iterator
-    __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
-    { return __it.base(); }
-# 1003 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-  template<typename _Iterator>
-    class move_iterator
-    {
-    protected:
-      _Iterator _M_current;
-
-      typedef iterator_traits<_Iterator> __traits_type;
-      typedef typename __traits_type::reference __base_ref;
-
-    public:
-      typedef _Iterator iterator_type;
-      typedef typename __traits_type::iterator_category iterator_category;
-      typedef typename __traits_type::value_type value_type;
-      typedef typename __traits_type::difference_type difference_type;
-
-      typedef _Iterator pointer;
-
-
-      typedef typename conditional<is_reference<__base_ref>::value,
-    typename remove_reference<__base_ref>::type&&,
-    __base_ref>::type reference;
-
-     
-      move_iterator()
-      : _M_current() { }
-
-      explicit
-      move_iterator(iterator_type __i)
-      : _M_current(__i) { }
-
-      template<typename _Iter>
-
- move_iterator(const move_iterator<_Iter>& __i)
- : _M_current(__i.base()) { }
-
-      iterator_type
-      base() const
-      { return _M_current; }
-
-      reference
-      operator*() const
-      { return static_cast<reference>(*_M_current); }
-
-      pointer
-      operator->() const
-      { return _M_current; }
-
-      move_iterator&
-      operator++()
-      {
- ++_M_current;
- return *this;
-      }
-
-      move_iterator
-      operator++(int)
-      {
- move_iterator __tmp = *this;
- ++_M_current;
- return __tmp;
-      }
-
-      move_iterator&
-      operator--()
-      {
- --_M_current;
- return *this;
-      }
-
-      move_iterator
-      operator--(int)
-      {
- move_iterator __tmp = *this;
- --_M_current;
- return __tmp;
-      }
-
-      move_iterator
-      operator+(difference_type __n) const
-      { return move_iterator(_M_current + __n); }
-
-      move_iterator&
-      operator+=(difference_type __n)
-      {
- _M_current += __n;
- return *this;
-      }
-
-      move_iterator
-      operator-(difference_type __n) const
-      { return move_iterator(_M_current - __n); }
-
-      move_iterator&
-      operator-=(difference_type __n)
-      {
- _M_current -= __n;
- return *this;
-      }
-
-      reference
-      operator[](difference_type __n) const
-      { return std::move(_M_current[__n]); }
-    };
-
-
-
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator==(const move_iterator<_IteratorL>& __x,
-        const move_iterator<_IteratorR>& __y)
-    { return __x.base() == __y.base(); }
-
-  template<typename _Iterator>
-    inline bool
-    operator==(const move_iterator<_Iterator>& __x,
-        const move_iterator<_Iterator>& __y)
-    { return __x.base() == __y.base(); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator!=(const move_iterator<_IteratorL>& __x,
-        const move_iterator<_IteratorR>& __y)
-    { return !(__x == __y); }
-
-  template<typename _Iterator>
-    inline bool
-    operator!=(const move_iterator<_Iterator>& __x,
-        const move_iterator<_Iterator>& __y)
-    { return !(__x == __y); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator<(const move_iterator<_IteratorL>& __x,
-       const move_iterator<_IteratorR>& __y)
-    { return __x.base() < __y.base(); }
-
-  template<typename _Iterator>
-    inline bool
-    operator<(const move_iterator<_Iterator>& __x,
-       const move_iterator<_Iterator>& __y)
-    { return __x.base() < __y.base(); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator<=(const move_iterator<_IteratorL>& __x,
-        const move_iterator<_IteratorR>& __y)
-    { return !(__y < __x); }
-
-  template<typename _Iterator>
-    inline bool
-    operator<=(const move_iterator<_Iterator>& __x,
-        const move_iterator<_Iterator>& __y)
-    { return !(__y < __x); }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator>(const move_iterator<_IteratorL>& __x,
-       const move_iterator<_IteratorR>& __y)
-    { return __y < __x; }
-
-  template<typename _Iterator>
-    inline bool
-    operator>(const move_iterator<_Iterator>& __x,
-       const move_iterator<_Iterator>& __y)
-    { return __y < __x; }
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline bool
-    operator>=(const move_iterator<_IteratorL>& __x,
-        const move_iterator<_IteratorR>& __y)
-    { return !(__x < __y); }
-
-  template<typename _Iterator>
-    inline bool
-    operator>=(const move_iterator<_Iterator>& __x,
-        const move_iterator<_Iterator>& __y)
-    { return !(__x < __y); }
-
-
-  template<typename _IteratorL, typename _IteratorR>
-    inline auto
-    operator-(const move_iterator<_IteratorL>& __x,
-       const move_iterator<_IteratorR>& __y)
-    -> decltype(__x.base() - __y.base())
-    { return __x.base() - __y.base(); }
-
-  template<typename _Iterator>
-    inline move_iterator<_Iterator>
-    operator+(typename move_iterator<_Iterator>::difference_type __n,
-       const move_iterator<_Iterator>& __x)
-    { return __x + __n; }
-
-  template<typename _Iterator>
-    inline move_iterator<_Iterator>
-    make_move_iterator(_Iterator __i)
-    { return move_iterator<_Iterator>(__i); }
-
-  template<typename _Iterator, typename _ReturnType
-    = typename conditional<__move_if_noexcept_cond
-      <typename iterator_traits<_Iterator>::value_type>::value,
-                _Iterator, move_iterator<_Iterator>>::type>
-    inline _ReturnType
-    __make_move_if_noexcept_iterator(_Iterator __i)
-    { return _ReturnType(__i); }
-
-
-
-  template<typename _Tp, typename _ReturnType
-    = typename conditional<__move_if_noexcept_cond<_Tp>::value,
-      const _Tp*, move_iterator<_Tp*>>::type>
-    inline _ReturnType
-    __make_move_if_noexcept_iterator(_Tp* __i)
-    { return _ReturnType(__i); }
-
-
-
-  template<typename _Iterator>
-    auto
-    __niter_base(move_iterator<_Iterator> __it)
-    -> decltype(make_move_iterator(__niter_base(__it.base())))
-    { return make_move_iterator(__niter_base(__it.base())); }
-
-  template<typename _Iterator>
-    struct __is_move_iterator<move_iterator<_Iterator> >
-    {
-      enum { __value = 1 };
-      typedef __true_type __type;
-    };
-
-  template<typename _Iterator>
-    auto
-    __miter_base(move_iterator<_Iterator> __it)
-    -> decltype(__miter_base(__it.base()))
-    { return __miter_base(__it.base()); }
-# 1268 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_iterator.h" 3
-
-}
-# 68 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 2 3
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/debug/debug.h" 1 3
-# 48 "../x86_64-pc-linux-gnu/libstdc++-v3/include/debug/debug.h" 3
-namespace std
-{
-  namespace __debug { }
-}
-
-
-
-
-namespace __gnu_debug
-{
-  using namespace std::__debug;
-}
-# 70 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 2 3
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/predefined_ops.h" 1 3
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/predefined_ops.h" 3
-namespace __gnu_cxx
-{
-namespace __ops
-{
-  struct _Iter_less_iter
-  {
-    template<typename _Iterator1, typename _Iterator2>
-      constexpr
-      bool
-      operator()(_Iterator1 __it1, _Iterator2 __it2) const
-      { return *__it1 < *__it2; }
-  };
-
-  constexpr
-  inline _Iter_less_iter
-  __iter_less_iter()
-  { return _Iter_less_iter(); }
-
-  struct _Iter_less_val
-  {
-
-    constexpr _Iter_less_val() = default;
-
-
-
-
-    explicit
-    _Iter_less_val(_Iter_less_iter) { }
-
-    template<typename _Iterator, typename _Value>
-      bool
-      operator()(_Iterator __it, _Value& __val) const
-      { return *__it < __val; }
-  };
-
-  inline _Iter_less_val
-  __iter_less_val()
-  { return _Iter_less_val(); }
-
-  inline _Iter_less_val
-  __iter_comp_val(_Iter_less_iter)
-  { return _Iter_less_val(); }
-
-  struct _Val_less_iter
-  {
-
-    constexpr _Val_less_iter() = default;
-
-
-
-
-    explicit
-    _Val_less_iter(_Iter_less_iter) { }
-
-    template<typename _Value, typename _Iterator>
-      bool
-      operator()(_Value& __val, _Iterator __it) const
-      { return __val < *__it; }
-  };
-
-  inline _Val_less_iter
-  __val_less_iter()
-  { return _Val_less_iter(); }
-
-  inline _Val_less_iter
-  __val_comp_iter(_Iter_less_iter)
-  { return _Val_less_iter(); }
-
-  struct _Iter_equal_to_iter
-  {
-    template<typename _Iterator1, typename _Iterator2>
-      bool
-      operator()(_Iterator1 __it1, _Iterator2 __it2) const
-      { return *__it1 == *__it2; }
-  };
-
-  inline _Iter_equal_to_iter
-  __iter_equal_to_iter()
-  { return _Iter_equal_to_iter(); }
-
-  struct _Iter_equal_to_val
-  {
-    template<typename _Iterator, typename _Value>
-      bool
-      operator()(_Iterator __it, _Value& __val) const
-      { return *__it == __val; }
-  };
-
-  inline _Iter_equal_to_val
-  __iter_equal_to_val()
-  { return _Iter_equal_to_val(); }
-
-  inline _Iter_equal_to_val
-  __iter_comp_val(_Iter_equal_to_iter)
-  { return _Iter_equal_to_val(); }
-
-  template<typename _Compare>
-    struct _Iter_comp_iter
-    {
-      _Compare _M_comp;
-
-      explicit constexpr
-      _Iter_comp_iter(_Compare __comp)
- : _M_comp(std::move(__comp))
-      { }
-
-      template<typename _Iterator1, typename _Iterator2>
-        constexpr
-        bool
-        operator()(_Iterator1 __it1, _Iterator2 __it2)
-        { return bool(_M_comp(*__it1, *__it2)); }
-    };
-
-  template<typename _Compare>
-    constexpr
-    inline _Iter_comp_iter<_Compare>
-    __iter_comp_iter(_Compare __comp)
-    { return _Iter_comp_iter<_Compare>(std::move(__comp)); }
-
-  template<typename _Compare>
-    struct _Iter_comp_val
-    {
-      _Compare _M_comp;
-
-      explicit
-      _Iter_comp_val(_Compare __comp)
- : _M_comp(std::move(__comp))
-      { }
-
-      explicit
-      _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
- : _M_comp(__comp._M_comp)
-      { }
-
-
-      explicit
-      _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
- : _M_comp(std::move(__comp._M_comp))
-      { }
-
-
-      template<typename _Iterator, typename _Value>
- bool
- operator()(_Iterator __it, _Value& __val)
- { return bool(_M_comp(*__it, __val)); }
-    };
-
-  template<typename _Compare>
-   inline _Iter_comp_val<_Compare>
-    __iter_comp_val(_Compare __comp)
-    { return _Iter_comp_val<_Compare>(std::move(__comp)); }
-
-  template<typename _Compare>
-    inline _Iter_comp_val<_Compare>
-    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
-    { return _Iter_comp_val<_Compare>(std::move(__comp)); }
-
-  template<typename _Compare>
-    struct _Val_comp_iter
-    {
-      _Compare _M_comp;
-
-      explicit
-      _Val_comp_iter(_Compare __comp)
- : _M_comp(std::move(__comp))
-      { }
-
-      explicit
-      _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
- : _M_comp(__comp._M_comp)
-      { }
-
-
-      explicit
-      _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
- : _M_comp(std::move(__comp._M_comp))
-      { }
-
-
-      template<typename _Value, typename _Iterator>
- bool
- operator()(_Value& __val, _Iterator __it)
- { return bool(_M_comp(__val, *__it)); }
-    };
-
-  template<typename _Compare>
-    inline _Val_comp_iter<_Compare>
-    __val_comp_iter(_Compare __comp)
-    { return _Val_comp_iter<_Compare>(std::move(__comp)); }
-
-  template<typename _Compare>
-    inline _Val_comp_iter<_Compare>
-    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
-    { return _Val_comp_iter<_Compare>(std::move(__comp)); }
-
-  template<typename _Value>
-    struct _Iter_equals_val
-    {
-      _Value& _M_value;
-
-      explicit
-      _Iter_equals_val(_Value& __value)
- : _M_value(__value)
-      { }
-
-      template<typename _Iterator>
- bool
- operator()(_Iterator __it)
- { return *__it == _M_value; }
-    };
-
-  template<typename _Value>
-    inline _Iter_equals_val<_Value>
-    __iter_equals_val(_Value& __val)
-    { return _Iter_equals_val<_Value>(__val); }
-
-  template<typename _Iterator1>
-    struct _Iter_equals_iter
-    {
-      _Iterator1 _M_it1;
-
-      explicit
-      _Iter_equals_iter(_Iterator1 __it1)
- : _M_it1(__it1)
-      { }
-
-      template<typename _Iterator2>
- bool
- operator()(_Iterator2 __it2)
- { return *__it2 == *_M_it1; }
-    };
-
-  template<typename _Iterator>
-    inline _Iter_equals_iter<_Iterator>
-    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
-    { return _Iter_equals_iter<_Iterator>(__it); }
-
-  template<typename _Predicate>
-    struct _Iter_pred
-    {
-      _Predicate _M_pred;
-
-      explicit
-      _Iter_pred(_Predicate __pred)
- : _M_pred(std::move(__pred))
-      { }
-
-      template<typename _Iterator>
- bool
- operator()(_Iterator __it)
- { return bool(_M_pred(*__it)); }
-    };
-
-  template<typename _Predicate>
-    inline _Iter_pred<_Predicate>
-    __pred_iter(_Predicate __pred)
-    { return _Iter_pred<_Predicate>(std::move(__pred)); }
-
-  template<typename _Compare, typename _Value>
-    struct _Iter_comp_to_val
-    {
-      _Compare _M_comp;
-      _Value& _M_value;
-
-      _Iter_comp_to_val(_Compare __comp, _Value& __value)
- : _M_comp(std::move(__comp)), _M_value(__value)
-      { }
-
-      template<typename _Iterator>
- bool
- operator()(_Iterator __it)
- { return bool(_M_comp(*__it, _M_value)); }
-    };
-
-  template<typename _Compare, typename _Value>
-    _Iter_comp_to_val<_Compare, _Value>
-    __iter_comp_val(_Compare __comp, _Value &__val)
-    {
-      return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val);
-    }
-
-  template<typename _Compare, typename _Iterator1>
-    struct _Iter_comp_to_iter
-    {
-      _Compare _M_comp;
-      _Iterator1 _M_it1;
-
-      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
- : _M_comp(std::move(__comp)), _M_it1(__it1)
-      { }
-
-      template<typename _Iterator2>
- bool
- operator()(_Iterator2 __it2)
- { return bool(_M_comp(*__it2, *_M_it1)); }
-    };
-
-  template<typename _Compare, typename _Iterator>
-    inline _Iter_comp_to_iter<_Compare, _Iterator>
-    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
-    {
-      return _Iter_comp_to_iter<_Compare, _Iterator>(
-   std::move(__comp._M_comp), __it);
-    }
-
-  template<typename _Predicate>
-    struct _Iter_negate
-    {
-      _Predicate _M_pred;
-
-      explicit
-      _Iter_negate(_Predicate __pred)
- : _M_pred(std::move(__pred))
-      { }
-
-      template<typename _Iterator>
- bool
- operator()(_Iterator __it)
- { return !bool(_M_pred(*__it)); }
-    };
-
-  template<typename _Predicate>
-    inline _Iter_negate<_Predicate>
-    __negate(_Iter_pred<_Predicate> __pred)
-    { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); }
-
-}
-}
-# 72 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 2 3
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-# 118 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2>
-    inline void
-    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
-    {
-
-     
-
-     
-# 148 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-      swap(*__a, *__b);
-
-    }
-# 164 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _ForwardIterator1, typename _ForwardIterator2>
-    _ForwardIterator2
-    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-  _ForwardIterator2 __first2)
-    {
-
-     
-
-     
-
-      ;
-
-      for (; __first1 != __last1; ++__first1, (void)++__first2)
- std::iter_swap(__first1, __first2);
-      return __first2;
-    }
-# 192 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _Tp>
-    constexpr
-    inline const _Tp&
-    min(const _Tp& __a, const _Tp& __b)
-    {
-
-     
-
-      if (__b < __a)
- return __b;
-      return __a;
-    }
-# 216 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _Tp>
-    constexpr
-    inline const _Tp&
-    max(const _Tp& __a, const _Tp& __b)
-    {
-
-     
-
-      if (__a < __b)
- return __b;
-      return __a;
-    }
-# 240 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _Tp, typename _Compare>
-    constexpr
-    inline const _Tp&
-    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
-    {
-
-      if (__comp(__b, __a))
- return __b;
-      return __a;
-    }
-# 262 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _Tp, typename _Compare>
-    constexpr
-    inline const _Tp&
-    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
-    {
-
-      if (__comp(__a, __b))
- return __b;
-      return __a;
-    }
-
-
-
-  template<typename _Iterator>
-    inline _Iterator
-    __niter_base(_Iterator __it)
-    { return __it; }
-
-
-
-
-
-
-
-  template<bool, bool, typename>
-    struct __copy_move
-    {
-      template<typename _II, typename _OI>
- static _OI
- __copy_m(_II __first, _II __last, _OI __result)
- {
-   for (; __first != __last; ++__result, (void)++__first)
-     *__result = *__first;
-   return __result;
- }
-    };
-
-
-  template<typename _Category>
-    struct __copy_move<true, false, _Category>
-    {
-      template<typename _II, typename _OI>
- static _OI
- __copy_m(_II __first, _II __last, _OI __result)
- {
-   for (; __first != __last; ++__result, (void)++__first)
-     *__result = std::move(*__first);
-   return __result;
- }
-    };
-
-
-  template<>
-    struct __copy_move<false, false, random_access_iterator_tag>
-    {
-      template<typename _II, typename _OI>
- static _OI
- __copy_m(_II __first, _II __last, _OI __result)
- {
-   typedef typename iterator_traits<_II>::difference_type _Distance;
-   for(_Distance __n = __last - __first; __n > 0; --__n)
-     {
-       *__result = *__first;
-       ++__first;
-       ++__result;
-     }
-   return __result;
- }
-    };
-
-
-  template<>
-    struct __copy_move<true, false, random_access_iterator_tag>
-    {
-      template<typename _II, typename _OI>
- static _OI
- __copy_m(_II __first, _II __last, _OI __result)
- {
-   typedef typename iterator_traits<_II>::difference_type _Distance;
-   for(_Distance __n = __last - __first; __n > 0; --__n)
-     {
-       *__result = std::move(*__first);
-       ++__first;
-       ++__result;
-     }
-   return __result;
- }
-    };
-
-
-  template<bool _IsMove>
-    struct __copy_move<_IsMove, true, random_access_iterator_tag>
-    {
-      template<typename _Tp>
- static _Tp*
- __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
- {
-
-   using __assignable = conditional<_IsMove,
-        is_move_assignable<_Tp>,
-        is_copy_assignable<_Tp>>;
-
-   static_assert( __assignable::type::value, "type is not assignable" );
-
-   const ptrdiff_t _Num = __last - __first;
-   if (_Num)
-     __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
-   return __result + _Num;
- }
-    };
-
-  template<bool _IsMove, typename _II, typename _OI>
-    inline _OI
-    __copy_move_a(_II __first, _II __last, _OI __result)
-    {
-      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
-      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
-      typedef typename iterator_traits<_II>::iterator_category _Category;
-      const bool __simple = (__is_trivial(_ValueTypeI)
-        && __is_pointer<_II>::__value
-        && __is_pointer<_OI>::__value
-        && __are_same<_ValueTypeI, _ValueTypeO>::__value);
-
-      return std::__copy_move<_IsMove, __simple,
-         _Category>::__copy_m(__first, __last, __result);
-    }
-
-
-
-  template<typename _CharT>
-    struct char_traits;
-
-  template<typename _CharT, typename _Traits>
-    class istreambuf_iterator;
-
-  template<typename _CharT, typename _Traits>
-    class ostreambuf_iterator;
-
-  template<bool _IsMove, typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
-    __copy_move_a2(_CharT*, _CharT*,
-     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
-
-  template<bool _IsMove, typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
-    __copy_move_a2(const _CharT*, const _CharT*,
-     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
-
-  template<bool _IsMove, typename _CharT>
-    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
-        _CharT*>::__type
-    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
-     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
-
-  template<bool _IsMove, typename _II, typename _OI>
-    inline _OI
-    __copy_move_a2(_II __first, _II __last, _OI __result)
-    {
-      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
-          std::__niter_base(__last),
-          std::__niter_base(__result)));
-    }
-# 444 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _II, typename _OI>
-    inline _OI
-    copy(_II __first, _II __last, _OI __result)
-    {
-
-     
-     
-
-      ;
-
-      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
-       (std::__miter_base(__first), std::__miter_base(__last),
-        __result));
-    }
-# 477 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _II, typename _OI>
-    inline _OI
-    move(_II __first, _II __last, _OI __result)
-    {
-
-     
-     
-
-      ;
-
-      return std::__copy_move_a2<true>(std::__miter_base(__first),
-           std::__miter_base(__last), __result);
-    }
-
-
-
-
-
-
-  template<bool, bool, typename>
-    struct __copy_move_backward
-    {
-      template<typename _BI1, typename _BI2>
- static _BI2
- __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
- {
-   while (__first != __last)
-     *--__result = *--__last;
-   return __result;
- }
-    };
-
-
-  template<typename _Category>
-    struct __copy_move_backward<true, false, _Category>
-    {
-      template<typename _BI1, typename _BI2>
- static _BI2
- __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
- {
-   while (__first != __last)
-     *--__result = std::move(*--__last);
-   return __result;
- }
-    };
-
-
-  template<>
-    struct __copy_move_backward<false, false, random_access_iterator_tag>
-    {
-      template<typename _BI1, typename _BI2>
- static _BI2
- __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
- {
-   typename iterator_traits<_BI1>::difference_type __n;
-   for (__n = __last - __first; __n > 0; --__n)
-     *--__result = *--__last;
-   return __result;
- }
-    };
-
-
-  template<>
-    struct __copy_move_backward<true, false, random_access_iterator_tag>
-    {
-      template<typename _BI1, typename _BI2>
- static _BI2
- __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
- {
-   typename iterator_traits<_BI1>::difference_type __n;
-   for (__n = __last - __first; __n > 0; --__n)
-     *--__result = std::move(*--__last);
-   return __result;
- }
-    };
-
-
-  template<bool _IsMove>
-    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
-    {
-      template<typename _Tp>
- static _Tp*
- __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
- {
-
-   using __assignable = conditional<_IsMove,
-        is_move_assignable<_Tp>,
-        is_copy_assignable<_Tp>>;
-
-   static_assert( __assignable::type::value, "type is not assignable" );
-
-   const ptrdiff_t _Num = __last - __first;
-   if (_Num)
-     __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
-   return __result - _Num;
- }
-    };
-
-  template<bool _IsMove, typename _BI1, typename _BI2>
-    inline _BI2
-    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
-    {
-      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
-      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
-      typedef typename iterator_traits<_BI1>::iterator_category _Category;
-      const bool __simple = (__is_trivial(_ValueType1)
-        && __is_pointer<_BI1>::__value
-        && __is_pointer<_BI2>::__value
-        && __are_same<_ValueType1, _ValueType2>::__value);
-
-      return std::__copy_move_backward<_IsMove, __simple,
-           _Category>::__copy_move_b(__first,
-         __last,
-         __result);
-    }
-
-  template<bool _IsMove, typename _BI1, typename _BI2>
-    inline _BI2
-    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
-    {
-      return _BI2(std::__copy_move_backward_a<_IsMove>
-    (std::__niter_base(__first), std::__niter_base(__last),
-     std::__niter_base(__result)));
-    }
-# 620 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _BI1, typename _BI2>
-    inline _BI2
-    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
-    {
-
-     
-     
-     
-
-
-      ;
-
-      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
-       (std::__miter_base(__first), std::__miter_base(__last),
-        __result));
-    }
-# 656 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _BI1, typename _BI2>
-    inline _BI2
-    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
-    {
-
-     
-     
-     
-
-
-      ;
-
-      return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
-      std::__miter_base(__last),
-      __result);
-    }
-
-
-
-
-
-
-  template<typename _ForwardIterator, typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
-    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
-       const _Tp& __value)
-    {
-      for (; __first != __last; ++__first)
- *__first = __value;
-    }
-
-  template<typename _ForwardIterator, typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
-    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
-      const _Tp& __value)
-    {
-      const _Tp __tmp = __value;
-      for (; __first != __last; ++__first)
- *__first = __tmp;
-    }
-
-
-  template<typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
-    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
-    {
-      const _Tp __tmp = __c;
-      if (const size_t __len = __last - __first)
- __builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
-    }
-# 722 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _ForwardIterator, typename _Tp>
-    inline void
-    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
-    {
-
-     
-
-      ;
-
-      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
-      __value);
-    }
-
-  template<typename _OutputIterator, typename _Size, typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
-    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
-    {
-      for (__decltype(__n + 0) __niter = __n;
-    __niter > 0; --__niter, (void) ++__first)
- *__first = __value;
-      return __first;
-    }
-
-  template<typename _OutputIterator, typename _Size, typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
-    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
-    {
-      const _Tp __tmp = __value;
-      for (__decltype(__n + 0) __niter = __n;
-    __niter > 0; --__niter, (void) ++__first)
- *__first = __tmp;
-      return __first;
-    }
-
-  template<typename _Size, typename _Tp>
-    inline typename
-    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
-    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
-    {
-      std::__fill_a(__first, __first + __n, __c);
-      return __first + __n;
-    }
-# 782 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _OI, typename _Size, typename _Tp>
-    inline _OI
-    fill_n(_OI __first, _Size __n, const _Tp& __value)
-    {
-
-     
-
-      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
-    }
-
-  template<bool _BoolType>
-    struct __equal
-    {
-      template<typename _II1, typename _II2>
- static bool
- equal(_II1 __first1, _II1 __last1, _II2 __first2)
- {
-   for (; __first1 != __last1; ++__first1, (void) ++__first2)
-     if (!(*__first1 == *__first2))
-       return false;
-   return true;
- }
-    };
-
-  template<>
-    struct __equal<true>
-    {
-      template<typename _Tp>
- static bool
- equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
- {
-   if (const size_t __len = (__last1 - __first1))
-     return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) * __len);
-   return true;
- }
-    };
-
-  template<typename _II1, typename _II2>
-    inline bool
-    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
-    {
-      typedef typename iterator_traits<_II1>::value_type _ValueType1;
-      typedef typename iterator_traits<_II2>::value_type _ValueType2;
-      const bool __simple = ((__is_integer<_ValueType1>::__value
-         || __is_pointer<_ValueType1>::__value)
-        && __is_pointer<_II1>::__value
-        && __is_pointer<_II2>::__value
-        && __are_same<_ValueType1, _ValueType2>::__value);
-
-      return std::__equal<__simple>::equal(__first1, __last1, __first2);
-    }
-
-  template<typename, typename>
-    struct __lc_rai
-    {
-      template<typename _II1, typename _II2>
- static _II1
- __newlast1(_II1, _II1 __last1, _II2, _II2)
- { return __last1; }
-
-      template<typename _II>
- static bool
- __cnd2(_II __first, _II __last)
- { return __first != __last; }
-    };
-
-  template<>
-    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
-    {
-      template<typename _RAI1, typename _RAI2>
- static _RAI1
- __newlast1(_RAI1 __first1, _RAI1 __last1,
-     _RAI2 __first2, _RAI2 __last2)
- {
-   const typename iterator_traits<_RAI1>::difference_type
-     __diff1 = __last1 - __first1;
-   const typename iterator_traits<_RAI2>::difference_type
-     __diff2 = __last2 - __first2;
-   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
- }
-
-      template<typename _RAI>
- static bool
- __cnd2(_RAI, _RAI)
- { return true; }
-    };
-
-  template<typename _II1, typename _II2, typename _Compare>
-    bool
-    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
-       _II2 __first2, _II2 __last2,
-       _Compare __comp)
-    {
-      typedef typename iterator_traits<_II1>::iterator_category _Category1;
-      typedef typename iterator_traits<_II2>::iterator_category _Category2;
-      typedef std::__lc_rai<_Category1, _Category2> __rai_type;
-
-      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
-      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
-    ++__first1, (void)++__first2)
- {
-   if (__comp(__first1, __first2))
-     return true;
-   if (__comp(__first2, __first1))
-     return false;
- }
-      return __first1 == __last1 && __first2 != __last2;
-    }
-
-  template<bool _BoolType>
-    struct __lexicographical_compare
-    {
-      template<typename _II1, typename _II2>
- static bool __lc(_II1, _II1, _II2, _II2);
-    };
-
-  template<bool _BoolType>
-    template<typename _II1, typename _II2>
-      bool
-      __lexicographical_compare<_BoolType>::
-      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
-      {
- return std::__lexicographical_compare_impl(__first1, __last1,
-         __first2, __last2,
-     __gnu_cxx::__ops::__iter_less_iter());
-      }
-
-  template<>
-    struct __lexicographical_compare<true>
-    {
-      template<typename _Tp, typename _Up>
- static bool
- __lc(const _Tp* __first1, const _Tp* __last1,
-      const _Up* __first2, const _Up* __last2)
- {
-   const size_t __len1 = __last1 - __first1;
-   const size_t __len2 = __last2 - __first2;
-   if (const size_t __len = std::min(__len1, __len2))
-     if (int __result = __builtin_memcmp(__first1, __first2, __len))
-       return __result < 0;
-   return __len1 < __len2;
- }
-    };
-
-  template<typename _II1, typename _II2>
-    inline bool
-    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
-      _II2 __first2, _II2 __last2)
-    {
-      typedef typename iterator_traits<_II1>::value_type _ValueType1;
-      typedef typename iterator_traits<_II2>::value_type _ValueType2;
-      const bool __simple =
- (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
-  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
-  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
-  && __is_pointer<_II1>::__value
-  && __is_pointer<_II2>::__value);
-
-      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
-           __first2, __last2);
-    }
-
-  template<typename _ForwardIterator, typename _Tp, typename _Compare>
-    _ForwardIterator
-    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
-    const _Tp& __val, _Compare __comp)
-    {
-      typedef typename iterator_traits<_ForwardIterator>::difference_type
- _DistanceType;
-
-      _DistanceType __len = std::distance(__first, __last);
-
-      while (__len > 0)
- {
-   _DistanceType __half = __len >> 1;
-   _ForwardIterator __middle = __first;
-   std::advance(__middle, __half);
-   if (__comp(__middle, __val))
-     {
-       __first = __middle;
-       ++__first;
-       __len = __len - __half - 1;
-     }
-   else
-     __len = __half;
- }
-      return __first;
-    }
-# 982 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _ForwardIterator, typename _Tp>
-    inline _ForwardIterator
-    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
-  const _Tp& __val)
-    {
-
-     
-     
-
-      ;
-
-      return std::__lower_bound(__first, __last, __val,
-    __gnu_cxx::__ops::__iter_less_val());
-    }
-
-
-
-  inline constexpr int
-  __lg(int __n)
-  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
-
-  inline constexpr unsigned
-  __lg(unsigned __n)
-  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
-
-  inline constexpr long
-  __lg(long __n)
-  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
-
-  inline constexpr unsigned long
-  __lg(unsigned long __n)
-  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
-
-  inline constexpr long long
-  __lg(long long __n)
-  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
-
-  inline constexpr unsigned long long
-  __lg(unsigned long long __n)
-  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
-
-
-# 1037 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _II1, typename _II2>
-    inline bool
-    equal(_II1 __first1, _II1 __last1, _II2 __first2)
-    {
-
-     
-     
-     
-
-
-      ;
-
-      return std::__equal_aux(std::__niter_base(__first1),
-         std::__niter_base(__last1),
-         std::__niter_base(__first2));
-    }
-# 1069 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
-    inline bool
-    equal(_IIter1 __first1, _IIter1 __last1,
-   _IIter2 __first2, _BinaryPredicate __binary_pred)
-    {
-
-     
-     
-      ;
-
-      for (; __first1 != __last1; ++__first1, (void)++__first2)
- if (!bool(__binary_pred(*__first1, *__first2)))
-   return false;
-      return true;
-    }
-
-
-
-  template<typename _II1, typename _II2>
-    inline bool
-    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
-    {
-      using _RATag = random_access_iterator_tag;
-      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
-      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
-      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
-      if (_RAIters())
- {
-   auto __d1 = std::distance(__first1, __last1);
-   auto __d2 = std::distance(__first2, __last2);
-   if (__d1 != __d2)
-     return false;
-   return std::equal(__first1, __last1, __first2);
- }
-
-      for (; __first1 != __last1 && __first2 != __last2;
-   ++__first1, (void)++__first2)
- if (!(*__first1 == *__first2))
-   return false;
-      return __first1 == __last1 && __first2 == __last2;
-    }
-
-
-  template<typename _II1, typename _II2, typename _BinaryPredicate>
-    inline bool
-    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2,
-      _BinaryPredicate __binary_pred)
-    {
-      using _RATag = random_access_iterator_tag;
-      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
-      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
-      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
-      if (_RAIters())
- {
-   auto __d1 = std::distance(__first1, __last1);
-   auto __d2 = std::distance(__first2, __last2);
-   if (__d1 != __d2)
-     return false;
-   return std::equal(__first1, __last1, __first2,
-           __binary_pred);
- }
-
-      for (; __first1 != __last1 && __first2 != __last2;
-   ++__first1, (void)++__first2)
- if (!bool(__binary_pred(*__first1, *__first2)))
-   return false;
-      return __first1 == __last1 && __first2 == __last2;
-    }
-# 1156 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _II1, typename _II2>
-    inline bool
-    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
-    {
-
-     
-     
-     
-
-
-      ;
-      ;
-
-      return std::__equal4(__first1, __last1, __first2, __last2);
-    }
-# 1188 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
-    inline bool
-    equal(_IIter1 __first1, _IIter1 __last1,
-   _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
-    {
-
-     
-     
-      ;
-      ;
-
-      return std::__equal4(__first1, __last1, __first2, __last2,
-          __binary_pred);
-    }
-# 1219 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _II1, typename _II2>
-    inline bool
-    lexicographical_compare(_II1 __first1, _II1 __last1,
-       _II2 __first2, _II2 __last2)
-    {
-
-
-
-
-
-     
-     
-     
-     
-      ;
-      ;
-
-      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
-      std::__niter_base(__last1),
-      std::__niter_base(__first2),
-      std::__niter_base(__last2));
-    }
-# 1255 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _II1, typename _II2, typename _Compare>
-    inline bool
-    lexicographical_compare(_II1 __first1, _II1 __last1,
-       _II2 __first2, _II2 __last2, _Compare __comp)
-    {
-
-     
-     
-      ;
-      ;
-
-      return std::__lexicographical_compare_impl
- (__first1, __last1, __first2, __last2,
-  __gnu_cxx::__ops::__iter_comp_iter(__comp));
-    }
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _BinaryPredicate>
-    pair<_InputIterator1, _InputIterator2>
-    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-        _InputIterator2 __first2, _BinaryPredicate __binary_pred)
-    {
-      while (__first1 != __last1 && __binary_pred(__first1, __first2))
- {
-   ++__first1;
-   ++__first2;
- }
-      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
-    }
-# 1298 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _InputIterator1, typename _InputIterator2>
-    inline pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2)
-    {
-
-     
-     
-     
-
-
-      ;
-
-      return std::__mismatch(__first1, __last1, __first2,
-        __gnu_cxx::__ops::__iter_equal_to_iter());
-    }
-# 1331 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _BinaryPredicate>
-    inline pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
-    {
-
-     
-     
-      ;
-
-      return std::__mismatch(__first1, __last1, __first2,
- __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
-    }
-
-
-
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _BinaryPredicate>
-    pair<_InputIterator1, _InputIterator2>
-    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-        _InputIterator2 __first2, _InputIterator2 __last2,
-        _BinaryPredicate __binary_pred)
-    {
-      while (__first1 != __last1 && __first2 != __last2
-      && __binary_pred(__first1, __first2))
- {
-   ++__first1;
-   ++__first2;
- }
-      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
-    }
-# 1378 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _InputIterator1, typename _InputIterator2>
-    inline pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2, _InputIterator2 __last2)
-    {
-
-     
-     
-     
-
-
-      ;
-      ;
-
-      return std::__mismatch(__first1, __last1, __first2, __last2,
-        __gnu_cxx::__ops::__iter_equal_to_iter());
-    }
-# 1413 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_algobase.h" 3
-  template<typename _InputIterator1, typename _InputIterator2,
-    typename _BinaryPredicate>
-    inline pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2, _InputIterator2 __last2,
-      _BinaryPredicate __binary_pred)
-    {
-
-     
-     
-      ;
-      ;
-
-      return std::__mismatch(__first1, __last1, __first2, __last2,
-        __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
-    }
-
-
-
-
-}
-# 64 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/allocator.h" 1 3
-# 46 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/allocator.h" 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/new_allocator.h" 1 3
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/new_allocator.h" 3
-# 1 "../../src/libstdc++-v3/libsupc++/new" 1 3
-# 37 "../../src/libstdc++-v3/libsupc++/new" 3
-       
-# 38 "../../src/libstdc++-v3/libsupc++/new" 3
-
-
-# 1 "../../src/libstdc++-v3/libsupc++/exception" 1 3
-# 33 "../../src/libstdc++-v3/libsupc++/exception" 3
-       
-# 34 "../../src/libstdc++-v3/libsupc++/exception" 3
-
-#pragma GCC visibility push(default)
-
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception.h" 1 3
-# 34 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception.h" 3
-       
-# 35 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception.h" 3
-
-#pragma GCC visibility push(default)
-
-
-
-extern "C++" {
-
-namespace std
-{
-# 60 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception.h" 3
-  class exception
-  {
-  public:
-    exception() noexcept { }
-    virtual ~exception() noexcept;
-
-
-
-    virtual const char*
-    what() const noexcept;
-  };
-
-}
-
-}
-
-#pragma GCC visibility pop
-# 39 "../../src/libstdc++-v3/libsupc++/exception" 2 3
-
-extern "C++" {
-
-namespace std
-{
-
-
-  class bad_exception : public exception
-  {
-  public:
-    bad_exception() noexcept { }
-
-
-
-    virtual ~bad_exception() noexcept;
-
-
-    virtual const char*
-    what() const noexcept;
-  };
-
-
-  typedef void (*terminate_handler) ();
-
-
-  typedef void (*unexpected_handler) ();
-
-
-  terminate_handler set_terminate(terminate_handler) noexcept;
-
-
-
-  terminate_handler get_terminate() noexcept;
-
-
-
-
-  void terminate() noexcept __attribute__ ((__noreturn__));
-
-
-  unexpected_handler set_unexpected(unexpected_handler) noexcept;
-
-
-
-  unexpected_handler get_unexpected() noexcept;
-
-
-
-
-  void unexpected() __attribute__ ((__noreturn__));
-# 101 "../../src/libstdc++-v3/libsupc++/exception" 3
- 
-  bool uncaught_exception() noexcept __attribute__ ((__pure__));
-
-
-
-
-  int uncaught_exceptions() noexcept __attribute__ ((__pure__));
-
-
-
-}
-
-namespace __gnu_cxx
-{
-
-# 133 "../../src/libstdc++-v3/libsupc++/exception" 3
-  void __verbose_terminate_handler();
-
-
-}
-
-}
-
-#pragma GCC visibility pop
-
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception_ptr.h" 1 3
-# 34 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception_ptr.h" 3
-#pragma GCC visibility push(default)
-
-
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cxxabi_init_exception.h" 1 3
-# 34 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cxxabi_init_exception.h" 3
-       
-# 35 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cxxabi_init_exception.h" 3
-
-#pragma GCC visibility push(default)
-
-# 1 "./include/stddef.h" 1 3 4
-# 149 "./include/stddef.h" 3 4
-typedef long int ptrdiff_t;
-# 216 "./include/stddef.h" 3 4
-typedef long unsigned int size_t;
-# 426 "./include/stddef.h" 3 4
-typedef struct {
-  long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
-  long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
-# 437 "./include/stddef.h" 3 4
-} max_align_t;
-
-
-
-
-
-
-  typedef decltype(nullptr) nullptr_t;
-# 39 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cxxabi_init_exception.h" 2 3
-# 50 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/cxxabi_init_exception.h" 3
-namespace std
-{
-  class type_info;
-}
-
-namespace __cxxabiv1
-{
-  struct __cxa_refcounted_exception;
-
-  extern "C"
-    {
-
-      void*
-      __cxa_allocate_exception(size_t) noexcept;
-
-
-      __cxa_refcounted_exception*
-      __cxa_init_primary_exception(void *object, std::type_info *tinfo,
-                void ( *dest) (void *)) noexcept;
-
-    }
-}
-
-
-
-#pragma GCC visibility pop
-# 39 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception_ptr.h" 2 3
-# 1 "../../src/libstdc++-v3/libsupc++/typeinfo" 1 3
-# 32 "../../src/libstdc++-v3/libsupc++/typeinfo" 3
-       
-# 33 "../../src/libstdc++-v3/libsupc++/typeinfo" 3
-
-
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/hash_bytes.h" 1 3
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/hash_bytes.h" 3
-       
-# 34 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/hash_bytes.h" 3
-
-
-
-namespace std
-{
-
-
-
-
-
-
-
-  size_t
-  _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
-
-
-
-
-
-  size_t
-  _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
-
-
-}
-# 37 "../../src/libstdc++-v3/libsupc++/typeinfo" 2 3
-
-
-#pragma GCC visibility push(default)
-
-extern "C++" {
-
-namespace __cxxabiv1
-{
-  class __class_type_info;
-}
-# 80 "../../src/libstdc++-v3/libsupc++/typeinfo" 3
-namespace std
-{
-
-
-
-
-
-
-  class type_info
-  {
-  public:
-
-
-
-
-    virtual ~type_info();
-
-
-
-    const char* name() const noexcept
-    { return __name[0] == '*' ? __name + 1 : __name; }
-# 115 "../../src/libstdc++-v3/libsupc++/typeinfo" 3
-    bool before(const type_info& __arg) const noexcept
-    { return (__name[0] == '*' && __arg.__name[0] == '*')
- ? __name < __arg.__name
- : __builtin_strcmp (__name, __arg.__name) < 0; }
-
-    bool operator==(const type_info& __arg) const noexcept
-    {
-      return ((__name == __arg.__name)
-       || (__name[0] != '*' &&
-    __builtin_strcmp (__name, __arg.__name) == 0));
-    }
-# 136 "../../src/libstdc++-v3/libsupc++/typeinfo" 3
-    bool operator!=(const type_info& __arg) const noexcept
-    { return !operator==(__arg); }
-
-
-    size_t hash_code() const noexcept
-    {
-
-      return _Hash_bytes(name(), __builtin_strlen(name()),
-    static_cast<size_t>(0xc70f6907UL));
-
-
-
-    }
-
-
-
-    virtual bool __is_pointer_p() const;
-
-
-    virtual bool __is_function_p() const;
-
-
-
-
-
-
-
-    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
-       unsigned __outer) const;
-
-
-    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
-        void **__obj_ptr) const;
-
-  protected:
-    const char *__name;
-
-    explicit type_info(const char *__n): __name(__n) { }
-
-  private:
-
-    type_info& operator=(const type_info&);
-    type_info(const type_info&);
-  };
-
-
-
-
-
-
-
-  class bad_cast : public exception
-  {
-  public:
-    bad_cast() noexcept { }
-
-
-
-    virtual ~bad_cast() noexcept;
-
-
-    virtual const char* what() const noexcept;
-  };
-
-
-
-
-
-  class bad_typeid : public exception
-  {
-  public:
-    bad_typeid () noexcept { }
-
-
-
-    virtual ~bad_typeid() noexcept;
-
-
-    virtual const char* what() const noexcept;
-  };
-}
-
-}
-
-#pragma GCC visibility pop
-# 40 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception_ptr.h" 2 3
-# 1 "../../src/libstdc++-v3/libsupc++/new" 1 3
-# 41 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception_ptr.h" 2 3
-
-extern "C++" {
-
-namespace std
-{
-  class type_info;
-
-
-
-
-
-  namespace __exception_ptr
-  {
-    class exception_ptr;
-  }
-
-  using __exception_ptr::exception_ptr;
-
-
-
-
-
-  exception_ptr current_exception() noexcept;
-
-  template<typename _Ex>
-  exception_ptr make_exception_ptr(_Ex) noexcept;
-
-
-  void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
-
-  namespace __exception_ptr
-  {
-    using std::rethrow_exception;
-
-
-
-
-
-    class exception_ptr
-    {
-      void* _M_exception_object;
-
-      explicit exception_ptr(void* __e) noexcept;
-
-      void _M_addref() noexcept;
-      void _M_release() noexcept;
-
-      void *_M_get() const noexcept __attribute__ ((__pure__));
-
-      friend exception_ptr std::current_exception() noexcept;
-      friend void std::rethrow_exception(exception_ptr);
-      template<typename _Ex>
-      friend exception_ptr std::make_exception_ptr(_Ex) noexcept;
-
-    public:
-      exception_ptr() noexcept;
-
-      exception_ptr(const exception_ptr&) noexcept;
-
-
-      exception_ptr(nullptr_t) noexcept
-      : _M_exception_object(0)
-      { }
-
-      exception_ptr(exception_ptr&& __o) noexcept
-      : _M_exception_object(__o._M_exception_object)
-      { __o._M_exception_object = 0; }
-# 117 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception_ptr.h" 3
-      exception_ptr&
-      operator=(const exception_ptr&) noexcept;
-
-
-      exception_ptr&
-      operator=(exception_ptr&& __o) noexcept
-      {
-        exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
-        return *this;
-      }
-
-
-      ~exception_ptr() noexcept;
-
-      void
-      swap(exception_ptr&) noexcept;
-# 144 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/exception_ptr.h" 3
-      explicit operator bool() const
-      { return _M_exception_object; }
-
-
-      friend bool
-      operator==(const exception_ptr&, const exception_ptr&)
- noexcept __attribute__ ((__pure__));
-
-      const class std::type_info*
-      __cxa_exception_type() const noexcept
- __attribute__ ((__pure__));
-    };
-
-    bool
-    operator==(const exception_ptr&, const exception_ptr&)
-      noexcept __attribute__ ((__pure__));
-
-    bool
-    operator!=(const exception_ptr&, const exception_ptr&)
-      noexcept __attribute__ ((__pure__));
-
-    inline void
-    swap(exception_ptr& __lhs, exception_ptr& __rhs)
-    { __lhs.swap(__rhs); }
-
-    template<typename _Ex>
-      inline void
-      __dest_thunk(void* __x)
-      { static_cast<_Ex*>(__x)->~_Ex(); }
-
-  }
-
-
-  template<typename _Ex>
-    exception_ptr
-    make_exception_ptr(_Ex __ex) noexcept
-    {
-
-      try
- {
-
-          void *__e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex));
-          (void)__cxxabiv1::__cxa_init_primary_exception(
-       __e, const_cast<std::type_info*>(&typeid(__ex)),
-       __exception_ptr::__dest_thunk<_Ex>);
-          ::new (__e) _Ex(__ex);
-          return exception_ptr(__e);
-
-
-
- }
-      catch(...)
- {
-   return current_exception();
- }
-
-
-
-    }
-
-
-}
-
-}
-
-#pragma GCC visibility pop
-# 144 "../../src/libstdc++-v3/libsupc++/exception" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/nested_exception.h" 1 3
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/nested_exception.h" 3
-#pragma GCC visibility push(default)
-# 42 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/nested_exception.h" 3
-extern "C++" {
-
-namespace std
-{
-
-
-
-
-
-
-  class nested_exception
-  {
-    exception_ptr _M_ptr;
-
-  public:
-    nested_exception() noexcept : _M_ptr(current_exception()) { }
-
-    nested_exception(const nested_exception&) noexcept = default;
-
-    nested_exception& operator=(const nested_exception&) noexcept = default;
-
-    virtual ~nested_exception() noexcept;
-
-    [[noreturn]]
-    void
-    rethrow_nested() const
-    {
-      if (_M_ptr)
- rethrow_exception(_M_ptr);
-      std::terminate();
-    }
-
-    exception_ptr
-    nested_ptr() const noexcept
-    { return _M_ptr; }
-  };
-
-  template<typename _Except>
-    struct _Nested_exception : public _Except, public nested_exception
-    {
-      explicit _Nested_exception(const _Except& __ex)
-      : _Except(__ex)
-      { }
-
-      explicit _Nested_exception(_Except&& __ex)
-      : _Except(static_cast<_Except&&>(__ex))
-      { }
-    };
-
-
-
-
-  template<typename _Tp>
-    [[noreturn]]
-    inline void
-    __throw_with_nested_impl(_Tp&& __t, true_type)
-    {
-      using _Up = typename remove_reference<_Tp>::type;
-      throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
-    }
-
-  template<typename _Tp>
-    [[noreturn]]
-    inline void
-    __throw_with_nested_impl(_Tp&& __t, false_type)
-    { throw std::forward<_Tp>(__t); }
-
-
-
-  template<typename _Tp>
-    [[noreturn]]
-    inline void
-    throw_with_nested(_Tp&& __t)
-    {
-      using _Up = typename decay<_Tp>::type;
-      using _CopyConstructible
- = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
-      static_assert(_CopyConstructible::value,
-   "throw_with_nested argument must be CopyConstructible");
-      using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
-       __not_<is_base_of<nested_exception, _Up>>>;
-      std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
-    }
-
-
-  template<typename _Tp>
-    using __rethrow_if_nested_cond = typename enable_if<
-      __and_<is_polymorphic<_Tp>,
-      __or_<__not_<is_base_of<nested_exception, _Tp>>,
-     is_convertible<_Tp*, nested_exception*>>>::value
-    >::type;
-
-
-  template<typename _Ex>
-    inline __rethrow_if_nested_cond<_Ex>
-    __rethrow_if_nested_impl(const _Ex* __ptr)
-    {
-      if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
- __ne_ptr->rethrow_nested();
-    }
-
-
-  inline void
-  __rethrow_if_nested_impl(const void*)
-  { }
-
-
-  template<typename _Ex>
-    inline void
-    rethrow_if_nested(const _Ex& __ex)
-    { std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
-
-
-}
-
-}
-
-
-
-#pragma GCC visibility pop
-# 145 "../../src/libstdc++-v3/libsupc++/exception" 2 3
-# 41 "../../src/libstdc++-v3/libsupc++/new" 2 3
-
-#pragma GCC visibility push(default)
-
-extern "C++" {
-
-namespace std
-{
-
-
-
-
-
-
-  class bad_alloc : public exception
-  {
-  public:
-    bad_alloc() throw() { }
-
-
-
-    virtual ~bad_alloc() throw();
-
-
-    virtual const char* what() const throw();
-  };
-
-
-  class bad_array_new_length : public bad_alloc
-  {
-  public:
-    bad_array_new_length() throw() { }
-
-
-
-    virtual ~bad_array_new_length() throw();
-
-
-    virtual const char* what() const throw();
-  };
-
-
-
-
-
-
-  struct nothrow_t
-  {
-
-    explicit nothrow_t() = default;
-
-  };
-
-  extern const nothrow_t nothrow;
-
-
-
-  typedef void (*new_handler)();
-
-
-
-  new_handler set_new_handler(new_handler) throw();
-
-
-
-  new_handler get_new_handler() noexcept;
-
-}
-# 120 "../../src/libstdc++-v3/libsupc++/new" 3
-void* operator new(std::size_t)
-  __attribute__((__externally_visible__));
-void* operator new[](std::size_t)
-  __attribute__((__externally_visible__));
-void operator delete(void*) noexcept
-  __attribute__((__externally_visible__));
-void operator delete[](void*) noexcept
-  __attribute__((__externally_visible__));
-
-void operator delete(void*, std::size_t) noexcept
-  __attribute__((__externally_visible__));
-void operator delete[](void*, std::size_t) noexcept
-  __attribute__((__externally_visible__));
-
-void* operator new(std::size_t, const std::nothrow_t&) noexcept
-  __attribute__((__externally_visible__));
-void* operator new[](std::size_t, const std::nothrow_t&) noexcept
-  __attribute__((__externally_visible__));
-void operator delete(void*, const std::nothrow_t&) noexcept
-  __attribute__((__externally_visible__));
-void operator delete[](void*, const std::nothrow_t&) noexcept
-  __attribute__((__externally_visible__));
-# 168 "../../src/libstdc++-v3/libsupc++/new" 3
-inline void* operator new(std::size_t, void* __p) noexcept
-{ return __p; }
-inline void* operator new[](std::size_t, void* __p) noexcept
-{ return __p; }
-
-
-inline void operator delete (void*, void*) noexcept { }
-inline void operator delete[](void*, void*) noexcept { }
-
-}
-# 216 "../../src/libstdc++-v3/libsupc++/new" 3
-#pragma GCC visibility pop
-# 34 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/new_allocator.h" 2 3
-
-
-
-
-
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-
-  using std::size_t;
-  using std::ptrdiff_t;
-# 57 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/new_allocator.h" 3
-  template<typename _Tp>
-    class new_allocator
-    {
-    public:
-      typedef size_t size_type;
-      typedef ptrdiff_t difference_type;
-      typedef _Tp* pointer;
-      typedef const _Tp* const_pointer;
-      typedef _Tp& reference;
-      typedef const _Tp& const_reference;
-      typedef _Tp value_type;
-
-      template<typename _Tp1>
- struct rebind
- { typedef new_allocator<_Tp1> other; };
-
-
-
-
-      typedef std::true_type propagate_on_container_move_assignment;
-
-
-      new_allocator() noexcept { }
-
-      new_allocator(const new_allocator&) noexcept { }
-
-      template<typename _Tp1>
- new_allocator(const new_allocator<_Tp1>&) noexcept { }
-
-      ~new_allocator() noexcept { }
-
-      pointer
-      address(reference __x) const noexcept
-      { return std::__addressof(__x); }
-
-      const_pointer
-      address(const_reference __x) const noexcept
-      { return std::__addressof(__x); }
-
-
-
-      pointer
-      allocate(size_type __n, const void* = static_cast<const void*>(0))
-      {
- if (__n > this->max_size())
-   std::__throw_bad_alloc();
-# 111 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/new_allocator.h" 3
- return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
-      }
-
-
-      void
-      deallocate(pointer __p, size_type)
-      {
-
-
-
-
-
-
-
- ::operator delete(__p);
-      }
-
-      size_type
-      max_size() const noexcept
-      { return size_t(-1) / sizeof(_Tp); }
-
-
-      template<typename _Up, typename... _Args>
- void
- construct(_Up* __p, _Args&&... __args)
- { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
-
-      template<typename _Up>
- void
- destroy(_Up* __p) { __p->~_Up(); }
-# 151 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/new_allocator.h" 3
-    };
-
-  template<typename _Tp>
-    inline bool
-    operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
-    { return true; }
-
-  template<typename _Tp>
-    inline bool
-    operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
-    { return false; }
-
-
-}
-# 34 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3
-
-
-namespace std
-{
-# 47 "../x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
-  template<typename _Tp>
-    using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
-}
-# 47 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/allocator.h" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/memoryfwd.h" 1 3
-# 46 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/memoryfwd.h" 3
-       
-# 47 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/memoryfwd.h" 3
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-# 63 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/memoryfwd.h" 3
-  template<typename>
-    class allocator;
-
-  template<>
-    class allocator<void>;
-
-
-  template<typename, typename>
-    struct uses_allocator;
-
-
-
-
-}
-# 48 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/allocator.h" 2 3
-# 57 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/allocator.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-
-  template<>
-    class allocator<void>
-    {
-    public:
-      typedef size_t size_type;
-      typedef ptrdiff_t difference_type;
-      typedef void* pointer;
-      typedef const void* const_pointer;
-      typedef void value_type;
-
-      template<typename _Tp1>
- struct rebind
- { typedef allocator<_Tp1> other; };
-
-
-
-
-      typedef true_type propagate_on_container_move_assignment;
-
-      typedef true_type is_always_equal;
-
-      template<typename _Up, typename... _Args>
- void
- construct(_Up* __p, _Args&&... __args)
- { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
-
-      template<typename _Up>
- void
- destroy(_Up* __p) { __p->~_Up(); }
-
-    };
-# 107 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/allocator.h" 3
-  template<typename _Tp>
-    class allocator : public __allocator_base<_Tp>
-    {
-   public:
-      typedef size_t size_type;
-      typedef ptrdiff_t difference_type;
-      typedef _Tp* pointer;
-      typedef const _Tp* const_pointer;
-      typedef _Tp& reference;
-      typedef const _Tp& const_reference;
-      typedef _Tp value_type;
-
-      template<typename _Tp1>
- struct rebind
- { typedef allocator<_Tp1> other; };
-
-
-
-
-      typedef true_type propagate_on_container_move_assignment;
-
-      typedef true_type is_always_equal;
-
-
-      allocator() throw() { }
-
-      allocator(const allocator& __a) throw()
-      : __allocator_base<_Tp>(__a) { }
-
-      template<typename _Tp1>
- allocator(const allocator<_Tp1>&) throw() { }
-
-      ~allocator() throw() { }
-
-
-    };
-
-  template<typename _T1, typename _T2>
-    inline bool
-    operator==(const allocator<_T1>&, const allocator<_T2>&)
-    noexcept
-    { return true; }
-
-  template<typename _Tp>
-    inline bool
-    operator==(const allocator<_Tp>&, const allocator<_Tp>&)
-    noexcept
-    { return true; }
-
-  template<typename _T1, typename _T2>
-    inline bool
-    operator!=(const allocator<_T1>&, const allocator<_T2>&)
-    noexcept
-    { return false; }
-
-  template<typename _Tp>
-    inline bool
-    operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
-    noexcept
-    { return false; }
-
-
-
-  template<typename _Tp>
-    class allocator<const _Tp>
-    {
-    public:
-      typedef _Tp value_type;
-      template<typename _Up> allocator(const allocator<_Up>&) { }
-    };
-
-  template<typename _Tp>
-    class allocator<volatile _Tp>
-    {
-    public:
-      typedef _Tp value_type;
-      template<typename _Up> allocator(const allocator<_Up>&) { }
-    };
-
-  template<typename _Tp>
-    class allocator<const volatile _Tp>
-    {
-    public:
-      typedef _Tp value_type;
-      template<typename _Up> allocator(const allocator<_Up>&) { }
-    };
-
-
-
-
-
-
-  extern template class allocator<char>;
-  extern template class allocator<wchar_t>;
-
-
-
-
-
-
-  template<typename _Alloc, bool = __is_empty(_Alloc)>
-    struct __alloc_swap
-    { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };
-
-  template<typename _Alloc>
-    struct __alloc_swap<_Alloc, false>
-    {
-      static void
-      _S_do_it(_Alloc& __one, _Alloc& __two) noexcept
-      {
-
- if (__one != __two)
-   swap(__one, __two);
-      }
-    };
-
-
-  template<typename _Alloc, bool = __is_empty(_Alloc)>
-    struct __alloc_neq
-    {
-      static bool
-      _S_do_it(const _Alloc&, const _Alloc&)
-      { return false; }
-    };
-
-  template<typename _Alloc>
-    struct __alloc_neq<_Alloc, false>
-    {
-      static bool
-      _S_do_it(const _Alloc& __one, const _Alloc& __two)
-      { return __one != __two; }
-    };
-
-
-  template<typename _Tp, bool
-    = __or_<is_copy_constructible<typename _Tp::value_type>,
-            is_nothrow_move_constructible<typename _Tp::value_type>>::value>
-    struct __shrink_to_fit_aux
-    { static bool _S_do_it(_Tp&) noexcept { return false; } };
-
-  template<typename _Tp>
-    struct __shrink_to_fit_aux<_Tp, true>
-    {
-      static bool
-      _S_do_it(_Tp& __c) noexcept
-      {
-
- try
-   {
-     _Tp(__make_move_if_noexcept_iterator(__c.begin()),
-  __make_move_if_noexcept_iterator(__c.end()),
-  __c.get_allocator()).swap(__c);
-     return true;
-   }
- catch(...)
-   { return false; }
-
-
-
-      }
-    };
-
-
-
-}
-# 65 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_function.h" 1 3
-# 63 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_function.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-# 104 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_function.h" 3
-  template<typename _Arg, typename _Result>
-    struct unary_function
-    {
-
-      typedef _Arg argument_type;
-
-
-      typedef _Result result_type;
-    };
-
-
-
-
-  template<typename _Arg1, typename _Arg2, typename _Result>
-    struct binary_function
-    {
-
-      typedef _Arg1 first_argument_type;
-
-
-      typedef _Arg2 second_argument_type;
-
-
-      typedef _Result result_type;
-    };
-# 144 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_function.h" 3
-  struct __is_transparent;
-
-  template<typename _Tp = void>
-    struct plus;
-
-  template<typename _Tp = void>
-    struct minus;
-
-  template<typename _Tp = void>
-    struct multiplies;
-
-  template<typename _Tp = void>
-    struct divides;
-
-  template<typename _Tp = void>
-    struct modulus;
-
-  template<typename _Tp = void>
-    struct negate;
-
-
-
-  template<typename _Tp>
-    struct plus : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x + __y; }
-    };
-
-
-  template<typename _Tp>
-    struct minus : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x - __y; }
-    };
-
-
-  template<typename _Tp>
-    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x * __y; }
-    };
-
-
-  template<typename _Tp>
-    struct divides : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x / __y; }
-    };
-
-
-  template<typename _Tp>
-    struct modulus : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x % __y; }
-    };
-
-
-  template<typename _Tp>
-    struct negate : public unary_function<_Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x) const
-      { return -__x; }
-    };
-
-
-
-
-
-  template<>
-    struct plus<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct minus<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct multiplies<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct divides<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct modulus<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct negate<void>
-    {
-      template <typename _Tp>
- constexpr
- auto
- operator()(_Tp&& __t) const
- noexcept(noexcept(-std::forward<_Tp>(__t)))
- -> decltype(-std::forward<_Tp>(__t))
- { return -std::forward<_Tp>(__t); }
-
-      typedef __is_transparent is_transparent;
-    };
-# 330 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_function.h" 3
-  template<typename _Tp = void>
-    struct equal_to;
-
-  template<typename _Tp = void>
-    struct not_equal_to;
-
-  template<typename _Tp = void>
-    struct greater;
-
-  template<typename _Tp = void>
-    struct less;
-
-  template<typename _Tp = void>
-    struct greater_equal;
-
-  template<typename _Tp = void>
-    struct less_equal;
-
-
-
-  template<typename _Tp>
-    struct equal_to : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x == __y; }
-    };
-
-
-  template<typename _Tp>
-    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x != __y; }
-    };
-
-
-  template<typename _Tp>
-    struct greater : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x > __y; }
-    };
-
-
-  template<typename _Tp>
-    struct less : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x < __y; }
-    };
-
-
-  template<typename _Tp>
-    struct greater_equal : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x >= __y; }
-    };
-
-
-  template<typename _Tp>
-    struct less_equal : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x <= __y; }
-    };
-
-
-
-  template<>
-    struct equal_to<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct not_equal_to<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct greater<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct less<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct greater_equal<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct less_equal<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-# 512 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_function.h" 3
-  template<typename _Tp = void>
-    struct logical_and;
-
-  template<typename _Tp = void>
-    struct logical_or;
-
-  template<typename _Tp = void>
-    struct logical_not;
-
-
-
-  template<typename _Tp>
-    struct logical_and : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x && __y; }
-    };
-
-
-  template<typename _Tp>
-    struct logical_or : public binary_function<_Tp, _Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x || __y; }
-    };
-
-
-  template<typename _Tp>
-    struct logical_not : public unary_function<_Tp, bool>
-    {
-      constexpr
-      bool
-      operator()(const _Tp& __x) const
-      { return !__x; }
-    };
-
-
-
-  template<>
-    struct logical_and<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct logical_or<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-  template<>
-    struct logical_not<void>
-    {
-      template <typename _Tp>
- constexpr
- auto
- operator()(_Tp&& __t) const
- noexcept(noexcept(!std::forward<_Tp>(__t)))
- -> decltype(!std::forward<_Tp>(__t))
- { return !std::forward<_Tp>(__t); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-
-
-
-  template<typename _Tp = void>
-    struct bit_and;
-
-  template<typename _Tp = void>
-    struct bit_or;
-
-  template<typename _Tp = void>
-    struct bit_xor;
-
-  template<typename _Tp = void>
-    struct bit_not;
-
-
-
-
-  template<typename _Tp>
-    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x & __y; }
-    };
-
-  template<typename _Tp>
-    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x | __y; }
-    };
-
-  template<typename _Tp>
-    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
-    {
-      constexpr
-      _Tp
-      operator()(const _Tp& __x, const _Tp& __y) const
-      { return __x ^ __y; }
-    };
-
-  template<typename _Tp>
-    struct bit_not : public unary_function<_Tp, _Tp>
-    {
-    constexpr
-      _Tp
-      operator()(const _Tp& __x) const
-      { return ~__x; }
-    };
-
-
-  template <>
-    struct bit_and<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-  template <>
-    struct bit_or<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-  template <>
-    struct bit_xor<void>
-    {
-      template <typename _Tp, typename _Up>
- constexpr
- auto
- operator()(_Tp&& __t, _Up&& __u) const
- noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
- -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
- { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
-
-      typedef __is_transparent is_transparent;
-    };
-
-  template <>
-    struct bit_not<void>
-    {
-      template <typename _Tp>
- constexpr
- auto
- operator()(_Tp&& __t) const
- noexcept(noexcept(~std::forward<_Tp>(__t)))
- -> decltype(~std::forward<_Tp>(__t))
- { return ~std::forward<_Tp>(__t); }
-
-      typedef __is_transparent is_transparent;
-    };
-# 740 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_function.h" 3
-  template<typename _Predicate>
-    class unary_negate
-    : public unary_function<typename _Predicate::argument_type, bool>
-    {
-    protected:
-      _Predicate _M_pred;
-
-    public:
-      constexpr
-      explicit
-      unary_negate(const _Predicate& __x) : _M_pred(__x) { }
-
-      constexpr
-      bool
-      operator()(const typename _Predicate::argument_type& __x) const
-      { return !_M_pred(__x); }
-    };
-
-
-  template<typename _Predicate>
-    constexpr
-    inline unary_negate<_Predicate>
-    not1(const _Predicate& __pred)
-    { return unary_negate<_Predicate>(__pred); }
-
-
-  template<typename _Predicate>
-    class binary_negate
-    : public binary_function<typename _Predicate::first_argument_type,
-        typename _Predicate::second_argument_type, bool>
-    {
-    protected:
-      _Predicate _M_pred;
-
-    public:
-      constexpr
-      explicit
-      binary_negate(const _Predicate& __x) : _M_pred(__x) { }
-
-      constexpr
-      bool
-      operator()(const typename _Predicate::first_argument_type& __x,
-   const typename _Predicate::second_argument_type& __y) const
-      { return !_M_pred(__x, __y); }
-    };
-
-
-  template<typename _Predicate>
-    constexpr
-    inline binary_negate<_Predicate>
-    not2(const _Predicate& __pred)
-    { return binary_negate<_Predicate>(__pred); }
-# 817 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_function.h" 3
-  template<typename _Arg, typename _Result>
-    class pointer_to_unary_function : public unary_function<_Arg, _Result>
-    {
-    protected:
-      _Result (*_M_ptr)(_Arg);
-
-    public:
-      pointer_to_unary_function() { }
-
-      explicit
-      pointer_to_unary_function(_Result (*__x)(_Arg))
-      : _M_ptr(__x) { }
-
-      _Result
-      operator()(_Arg __x) const
-      { return _M_ptr(__x); }
-    };
-
-
-  template<typename _Arg, typename _Result>
-    inline pointer_to_unary_function<_Arg, _Result>
-    ptr_fun(_Result (*__x)(_Arg))
-    { return pointer_to_unary_function<_Arg, _Result>(__x); }
-
-
-  template<typename _Arg1, typename _Arg2, typename _Result>
-    class pointer_to_binary_function
-    : public binary_function<_Arg1, _Arg2, _Result>
-    {
-    protected:
-      _Result (*_M_ptr)(_Arg1, _Arg2);
-
-    public:
-      pointer_to_binary_function() { }
-
-      explicit
-      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
-      : _M_ptr(__x) { }
-
-      _Result
-      operator()(_Arg1 __x, _Arg2 __y) const
-      { return _M_ptr(__x, __y); }
-    };
-
-
-  template<typename _Arg1, typename _Arg2, typename _Result>
-    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
-    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
-    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
-
-
-  template<typename _Tp>
-    struct _Identity
-    : public unary_function<_Tp, _Tp>
-    {
-      _Tp&
-      operator()(_Tp& __x) const
-      { return __x; }
-
-      const _Tp&
-      operator()(const _Tp& __x) const
-      { return __x; }
-    };
-
-
-  template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };
-
-  template<typename _Pair>
-    struct _Select1st
-    : public unary_function<_Pair, typename _Pair::first_type>
-    {
-      typename _Pair::first_type&
-      operator()(_Pair& __x) const
-      { return __x.first; }
-
-      const typename _Pair::first_type&
-      operator()(const _Pair& __x) const
-      { return __x.first; }
-
-
-      template<typename _Pair2>
-        typename _Pair2::first_type&
-        operator()(_Pair2& __x) const
-        { return __x.first; }
-
-      template<typename _Pair2>
-        const typename _Pair2::first_type&
-        operator()(const _Pair2& __x) const
-        { return __x.first; }
-
-    };
-
-  template<typename _Pair>
-    struct _Select2nd
-    : public unary_function<_Pair, typename _Pair::second_type>
-    {
-      typename _Pair::second_type&
-      operator()(_Pair& __x) const
-      { return __x.second; }
-
-      const typename _Pair::second_type&
-      operator()(const _Pair& __x) const
-      { return __x.second; }
-    };
-# 940 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_function.h" 3
-  template<typename _Ret, typename _Tp>
-    class mem_fun_t : public unary_function<_Tp*, _Ret>
-    {
-    public:
-      explicit
-      mem_fun_t(_Ret (_Tp::*__pf)())
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(_Tp* __p) const
-      { return (__p->*_M_f)(); }
-
-    private:
-      _Ret (_Tp::*_M_f)();
-    };
-
-
-
-  template<typename _Ret, typename _Tp>
-    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
-    {
-    public:
-      explicit
-      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(const _Tp* __p) const
-      { return (__p->*_M_f)(); }
-
-    private:
-      _Ret (_Tp::*_M_f)() const;
-    };
-
-
-
-  template<typename _Ret, typename _Tp>
-    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
-    {
-    public:
-      explicit
-      mem_fun_ref_t(_Ret (_Tp::*__pf)())
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(_Tp& __r) const
-      { return (__r.*_M_f)(); }
-
-    private:
-      _Ret (_Tp::*_M_f)();
-  };
-
-
-
-  template<typename _Ret, typename _Tp>
-    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
-    {
-    public:
-      explicit
-      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(const _Tp& __r) const
-      { return (__r.*_M_f)(); }
-
-    private:
-      _Ret (_Tp::*_M_f)() const;
-    };
-
-
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
-    {
-    public:
-      explicit
-      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(_Tp* __p, _Arg __x) const
-      { return (__p->*_M_f)(__x); }
-
-    private:
-      _Ret (_Tp::*_M_f)(_Arg);
-    };
-
-
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
-    {
-    public:
-      explicit
-      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(const _Tp* __p, _Arg __x) const
-      { return (__p->*_M_f)(__x); }
-
-    private:
-      _Ret (_Tp::*_M_f)(_Arg) const;
-    };
-
-
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
-    {
-    public:
-      explicit
-      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(_Tp& __r, _Arg __x) const
-      { return (__r.*_M_f)(__x); }
-
-    private:
-      _Ret (_Tp::*_M_f)(_Arg);
-    };
-
-
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
-    {
-    public:
-      explicit
-      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
-      : _M_f(__pf) { }
-
-      _Ret
-      operator()(const _Tp& __r, _Arg __x) const
-      { return (__r.*_M_f)(__x); }
-
-    private:
-      _Ret (_Tp::*_M_f)(_Arg) const;
-    };
-
-
-
-  template<typename _Ret, typename _Tp>
-    inline mem_fun_t<_Ret, _Tp>
-    mem_fun(_Ret (_Tp::*__f)())
-    { return mem_fun_t<_Ret, _Tp>(__f); }
-
-  template<typename _Ret, typename _Tp>
-    inline const_mem_fun_t<_Ret, _Tp>
-    mem_fun(_Ret (_Tp::*__f)() const)
-    { return const_mem_fun_t<_Ret, _Tp>(__f); }
-
-  template<typename _Ret, typename _Tp>
-    inline mem_fun_ref_t<_Ret, _Tp>
-    mem_fun_ref(_Ret (_Tp::*__f)())
-    { return mem_fun_ref_t<_Ret, _Tp>(__f); }
-
-  template<typename _Ret, typename _Tp>
-    inline const_mem_fun_ref_t<_Ret, _Tp>
-    mem_fun_ref(_Ret (_Tp::*__f)() const)
-    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    inline mem_fun1_t<_Ret, _Tp, _Arg>
-    mem_fun(_Ret (_Tp::*__f)(_Arg))
-    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
-    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
-    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
-    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
-    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
-
-  template<typename _Ret, typename _Tp, typename _Arg>
-    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
-    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
-    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
-
-
-
-
-}
-
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/backward/binders.h" 1 3
-# 60 "../x86_64-pc-linux-gnu/libstdc++-v3/include/backward/binders.h" 3
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-# 107 "../x86_64-pc-linux-gnu/libstdc++-v3/include/backward/binders.h" 3
-  template<typename _Operation>
-    class binder1st
-    : public unary_function<typename _Operation::second_argument_type,
-       typename _Operation::result_type>
-    {
-    protected:
-      _Operation op;
-      typename _Operation::first_argument_type value;
-
-    public:
-      binder1st(const _Operation& __x,
-  const typename _Operation::first_argument_type& __y)
-      : op(__x), value(__y) { }
-
-      typename _Operation::result_type
-      operator()(const typename _Operation::second_argument_type& __x) const
-      { return op(value, __x); }
-
-
-
-      typename _Operation::result_type
-      operator()(typename _Operation::second_argument_type& __x) const
-      { return op(value, __x); }
-    } __attribute__ ((__deprecated__));
-
-
-  template<typename _Operation, typename _Tp>
-    inline binder1st<_Operation>
-    bind1st(const _Operation& __fn, const _Tp& __x)
-    {
-      typedef typename _Operation::first_argument_type _Arg1_type;
-      return binder1st<_Operation>(__fn, _Arg1_type(__x));
-    }
-
-
-  template<typename _Operation>
-    class binder2nd
-    : public unary_function<typename _Operation::first_argument_type,
-       typename _Operation::result_type>
-    {
-    protected:
-      _Operation op;
-      typename _Operation::second_argument_type value;
-
-    public:
-      binder2nd(const _Operation& __x,
-  const typename _Operation::second_argument_type& __y)
-      : op(__x), value(__y) { }
-
-      typename _Operation::result_type
-      operator()(const typename _Operation::first_argument_type& __x) const
-      { return op(__x, value); }
-
-
-
-      typename _Operation::result_type
-      operator()(typename _Operation::first_argument_type& __x) const
-      { return op(__x, value); }
-    } __attribute__ ((__deprecated__));
-
-
-  template<typename _Operation, typename _Tp>
-    inline binder2nd<_Operation>
-    bind2nd(const _Operation& __fn, const _Tp& __x)
-    {
-      typedef typename _Operation::second_argument_type _Arg2_type;
-      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
-    }
-
-
-
-}
-
-#pragma GCC diagnostic pop
-# 1131 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_function.h" 2 3
-# 66 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 2 3
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/alloc_traits.h" 1 3
-# 32 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/alloc_traits.h" 3
-       
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/alloc_traits.h" 3
-
-
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 1 3
-# 41 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-  struct __allocator_traits_base
-  {
-    template<typename _Tp, typename _Up, typename = void>
-      struct __rebind : __replace_first_arg<_Tp, _Up> { };
-
-    template<typename _Tp, typename _Up>
-      struct __rebind<_Tp, _Up,
-        __void_t<typename _Tp::template rebind<_Up>::other>>
-      { using type = typename _Tp::template rebind<_Up>::other; };
-
-  protected:
-    template<typename _Tp>
-      using __pointer = typename _Tp::pointer;
-    template<typename _Tp>
-      using __c_pointer = typename _Tp::const_pointer;
-    template<typename _Tp>
-      using __v_pointer = typename _Tp::void_pointer;
-    template<typename _Tp>
-      using __cv_pointer = typename _Tp::const_void_pointer;
-    template<typename _Tp>
-      using __pocca = typename _Tp::propagate_on_container_copy_assignment;
-    template<typename _Tp>
-      using __pocma = typename _Tp::propagate_on_container_move_assignment;
-    template<typename _Tp>
-      using __pocs = typename _Tp::propagate_on_container_swap;
-    template<typename _Tp>
-      using __equal = typename _Tp::is_always_equal;
-  };
-
-  template<typename _Alloc, typename _Up>
-    using __alloc_rebind
-      = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
-
-
-
-
-
-  template<typename _Alloc>
-    struct allocator_traits : __allocator_traits_base
-    {
-
-      typedef _Alloc allocator_type;
-
-      typedef typename _Alloc::value_type value_type;
-
-
-
-
-
-
-      using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;
-
-    private:
-
-      template<template<typename> class _Func, typename _Tp, typename = void>
- struct _Ptr
- {
-   using type = typename pointer_traits<pointer>::template rebind<_Tp>;
- };
-
-      template<template<typename> class _Func, typename _Tp>
- struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
- {
-   using type = _Func<_Alloc>;
- };
-
-
-      template<typename _A2, typename _PtrT, typename = void>
- struct _Diff
- { using type = typename pointer_traits<_PtrT>::difference_type; };
-
-      template<typename _A2, typename _PtrT>
- struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
- { using type = typename _A2::difference_type; };
-
-
-      template<typename _A2, typename _DiffT, typename = void>
- struct _Size : make_unsigned<_DiffT> { };
-
-      template<typename _A2, typename _DiffT>
- struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
- { using type = typename _A2::size_type; };
-
-    public:
-
-
-
-
-
-
-      using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;
-
-
-
-
-
-
-
-      using void_pointer = typename _Ptr<__v_pointer, void>::type;
-
-
-
-
-
-
-
-      using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;
-
-
-
-
-
-
-
-      using difference_type = typename _Diff<_Alloc, pointer>::type;
-
-
-
-
-
-
-
-      using size_type = typename _Size<_Alloc, difference_type>::type;
-
-
-
-
-
-
-
-      using propagate_on_container_copy_assignment
- = __detected_or_t<false_type, __pocca, _Alloc>;
-
-
-
-
-
-
-
-      using propagate_on_container_move_assignment
- = __detected_or_t<false_type, __pocma, _Alloc>;
-
-
-
-
-
-
-
-      using propagate_on_container_swap
- = __detected_or_t<false_type, __pocs, _Alloc>;
-
-
-
-
-
-
-
-      using is_always_equal
- = __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;
-
-      template<typename _Tp>
- using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
-      template<typename _Tp>
- using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
-
-    private:
-      template<typename _Alloc2>
- static auto
- _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
- -> decltype(__a.allocate(__n, __hint))
- { return __a.allocate(__n, __hint); }
-
-      template<typename _Alloc2>
- static pointer
- _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
- { return __a.allocate(__n); }
-
-      template<typename _Tp, typename... _Args>
- struct __construct_helper
- {
-   template<typename _Alloc2,
-     typename = decltype(std::declval<_Alloc2*>()->construct(
-    std::declval<_Tp*>(), std::declval<_Args>()...))>
-     static true_type __test(int);
-
-   template<typename>
-     static false_type __test(...);
-
-   using type = decltype(__test<_Alloc>(0));
- };
-
-      template<typename _Tp, typename... _Args>
- using __has_construct
-   = typename __construct_helper<_Tp, _Args...>::type;
-
-      template<typename _Tp, typename... _Args>
- static _Require<__has_construct<_Tp, _Args...>>
- _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
- { __a.construct(__p, std::forward<_Args>(__args)...); }
-
-      template<typename _Tp, typename... _Args>
- static
- _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
-          is_constructible<_Tp, _Args...>>>
- _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
- { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
-
-      template<typename _Alloc2, typename _Tp>
- static auto
- _S_destroy(_Alloc2& __a, _Tp* __p, int)
- -> decltype(__a.destroy(__p))
- { __a.destroy(__p); }
-
-      template<typename _Alloc2, typename _Tp>
- static void
- _S_destroy(_Alloc2&, _Tp* __p, ...)
- { __p->~_Tp(); }
-
-      template<typename _Alloc2>
- static auto
- _S_max_size(_Alloc2& __a, int)
- -> decltype(__a.max_size())
- { return __a.max_size(); }
-
-      template<typename _Alloc2>
- static size_type
- _S_max_size(_Alloc2&, ...)
- {
-
-
-   return __gnu_cxx::__numeric_traits<size_type>::__max
-     / sizeof(value_type);
- }
-
-      template<typename _Alloc2>
- static auto
- _S_select(_Alloc2& __a, int)
- -> decltype(__a.select_on_container_copy_construction())
- { return __a.select_on_container_copy_construction(); }
-
-      template<typename _Alloc2>
- static _Alloc2
- _S_select(_Alloc2& __a, ...)
- { return __a; }
-
-    public:
-# 299 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      static pointer
-      allocate(_Alloc& __a, size_type __n)
-      { return __a.allocate(__n); }
-# 314 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      static pointer
-      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
-      { return _S_allocate(__a, __n, __hint, 0); }
-# 326 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      static void
-      deallocate(_Alloc& __a, pointer __p, size_type __n)
-      { __a.deallocate(__p, __n); }
-# 341 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      template<typename _Tp, typename... _Args>
- static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
- -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
- { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
-# 354 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      template<typename _Tp>
- static void destroy(_Alloc& __a, _Tp* __p)
- { _S_destroy(__a, __p, 0); }
-# 366 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      static size_type max_size(const _Alloc& __a) noexcept
-      { return _S_max_size(__a, 0); }
-# 377 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      static _Alloc
-      select_on_container_copy_construction(const _Alloc& __rhs)
-      { return _S_select(__rhs, 0); }
-    };
-
-
-  template<typename _Tp>
-    struct allocator_traits<allocator<_Tp>>
-    {
-
-      using allocator_type = allocator<_Tp>;
-
-      using value_type = _Tp;
-
-
-      using pointer = _Tp*;
-
-
-      using const_pointer = const _Tp*;
-
-
-      using void_pointer = void*;
-
-
-      using const_void_pointer = const void*;
-
-
-      using difference_type = std::ptrdiff_t;
-
-
-      using size_type = std::size_t;
-
-
-      using propagate_on_container_copy_assignment = false_type;
-
-
-      using propagate_on_container_move_assignment = true_type;
-
-
-      using propagate_on_container_swap = false_type;
-
-
-      using is_always_equal = true_type;
-
-      template<typename _Up>
- using rebind_alloc = allocator<_Up>;
-
-      template<typename _Up>
- using rebind_traits = allocator_traits<allocator<_Up>>;
-# 434 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      static pointer
-      allocate(allocator_type& __a, size_type __n)
-      { return __a.allocate(__n); }
-# 448 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      static pointer
-      allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
-      { return __a.allocate(__n, __hint); }
-# 460 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      static void
-      deallocate(allocator_type& __a, pointer __p, size_type __n)
-      { __a.deallocate(__p, __n); }
-# 472 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      template<typename _Up, typename... _Args>
- static void
- construct(allocator_type& __a, _Up* __p, _Args&&... __args)
- { __a.construct(__p, std::forward<_Args>(__args)...); }
-# 484 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/alloc_traits.h" 3
-      template<typename _Up>
- static void
- destroy(allocator_type& __a, _Up* __p)
- { __a.destroy(__p); }
-
-
-
-
-
-
-      static size_type
-      max_size(const allocator_type& __a) noexcept
-      { return __a.max_size(); }
-
-
-
-
-
-
-      static allocator_type
-      select_on_container_copy_construction(const allocator_type& __rhs)
-      { return __rhs; }
-    };
-
-
-  template<typename _Alloc>
-    inline void
-    __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
-    { __one = __two; }
-
-  template<typename _Alloc>
-    inline void
-    __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
-    { }
-
-  template<typename _Alloc>
-    inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
-    {
-      typedef allocator_traits<_Alloc> __traits;
-      typedef typename __traits::propagate_on_container_copy_assignment __pocca;
-      __do_alloc_on_copy(__one, __two, __pocca());
-    }
-
-  template<typename _Alloc>
-    inline _Alloc __alloc_on_copy(const _Alloc& __a)
-    {
-      typedef allocator_traits<_Alloc> __traits;
-      return __traits::select_on_container_copy_construction(__a);
-    }
-
-  template<typename _Alloc>
-    inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
-    { __one = std::move(__two); }
-
-  template<typename _Alloc>
-    inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
-    { }
-
-  template<typename _Alloc>
-    inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
-    {
-      typedef allocator_traits<_Alloc> __traits;
-      typedef typename __traits::propagate_on_container_move_assignment __pocma;
-      __do_alloc_on_move(__one, __two, __pocma());
-    }
-
-  template<typename _Alloc>
-    inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
-    {
-      using std::swap;
-      swap(__one, __two);
-    }
-
-  template<typename _Alloc>
-    inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
-    { }
-
-  template<typename _Alloc>
-    inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
-    {
-      typedef allocator_traits<_Alloc> __traits;
-      typedef typename __traits::propagate_on_container_swap __pocs;
-      __do_alloc_on_swap(__one, __two, __pocs());
-    }
-
-  template<typename _Alloc>
-    class __is_copy_insertable_impl
-    {
-      typedef allocator_traits<_Alloc> _Traits;
-
-      template<typename _Up, typename
-        = decltype(_Traits::construct(std::declval<_Alloc&>(),
-          std::declval<_Up*>(),
-          std::declval<const _Up&>()))>
- static true_type
- _M_select(int);
-
-      template<typename _Up>
- static false_type
- _M_select(...);
-
-    public:
-      typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
-    };
-
-
-  template<typename _Alloc>
-    struct __is_copy_insertable
-    : __is_copy_insertable_impl<_Alloc>::type
-    { };
-
-
-  template<typename _Tp>
-    struct __is_copy_insertable<allocator<_Tp>>
-    : is_copy_constructible<_Tp>
-    { };
-
-
-
-  template<typename _Alloc, typename = void>
-    struct __is_allocator : false_type { };
-
-  template<typename _Alloc>
-    struct __is_allocator<_Alloc,
-      __void_t<typename _Alloc::value_type,
-        decltype(std::declval<_Alloc&>().allocate(size_t{}))>>
-    : true_type { };
-
-  template<typename _Alloc>
-    using _RequireAllocator
-      = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type;
-
-
-
-}
-# 37 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/alloc_traits.h" 2 3
-
-
-
-
-namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-template<typename _Alloc, typename = typename _Alloc::value_type>
-  struct __alloc_traits
-
-  : std::allocator_traits<_Alloc>
-
-  {
-    typedef _Alloc allocator_type;
-
-    typedef std::allocator_traits<_Alloc> _Base_type;
-    typedef typename _Base_type::value_type value_type;
-    typedef typename _Base_type::pointer pointer;
-    typedef typename _Base_type::const_pointer const_pointer;
-    typedef typename _Base_type::size_type size_type;
-    typedef typename _Base_type::difference_type difference_type;
-
-    typedef value_type& reference;
-    typedef const value_type& const_reference;
-    using _Base_type::allocate;
-    using _Base_type::deallocate;
-    using _Base_type::construct;
-    using _Base_type::destroy;
-    using _Base_type::max_size;
-
-  private:
-    template<typename _Ptr>
-      using __is_custom_pointer
- = std::__and_<std::is_same<pointer, _Ptr>,
-        std::__not_<std::is_pointer<_Ptr>>>;
-
-  public:
-
-    template<typename _Ptr, typename... _Args>
-      static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
-      construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
-      {
- _Base_type::construct(__a, std::__to_address(__p),
-         std::forward<_Args>(__args)...);
-      }
-
-
-    template<typename _Ptr>
-      static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
-      destroy(_Alloc& __a, _Ptr __p)
-      { _Base_type::destroy(__a, std::__to_address(__p)); }
-
-    static _Alloc _S_select_on_copy(const _Alloc& __a)
-    { return _Base_type::select_on_container_copy_construction(__a); }
-
-    static void _S_on_swap(_Alloc& __a, _Alloc& __b)
-    { std::__alloc_on_swap(__a, __b); }
-
-    static constexpr bool _S_propagate_on_copy_assign()
-    { return _Base_type::propagate_on_container_copy_assignment::value; }
-
-    static constexpr bool _S_propagate_on_move_assign()
-    { return _Base_type::propagate_on_container_move_assignment::value; }
-
-    static constexpr bool _S_propagate_on_swap()
-    { return _Base_type::propagate_on_container_swap::value; }
-
-    static constexpr bool _S_always_equal()
-    { return _Base_type::is_always_equal::value; }
-
-    static constexpr bool _S_nothrow_move()
-    { return _S_propagate_on_move_assign() || _S_always_equal(); }
-
-    template<typename _Tp>
-      struct rebind
-      { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
-# 158 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/alloc_traits.h" 3
-  };
-
-
-}
-# 68 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 2 3
-
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/aligned_buffer.h" 1 3
-# 32 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/aligned_buffer.h" 3
-       
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/ext/aligned_buffer.h" 3
-
-
-
-
-
-
-
-namespace __gnu_cxx
-{
-
-
-
-
-  template<typename _Tp>
-    struct __aligned_membuf
-    {
-
-
-
-      struct _Tp2 { _Tp _M_t; };
-
-      alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)];
-
-      __aligned_membuf() = default;
-
-
-      __aligned_membuf(std::nullptr_t) { }
-
-      void*
-      _M_addr() noexcept
-      { return static_cast<void*>(&_M_storage); }
-
-      const void*
-      _M_addr() const noexcept
-      { return static_cast<const void*>(&_M_storage); }
-
-      _Tp*
-      _M_ptr() noexcept
-      { return static_cast<_Tp*>(_M_addr()); }
-
-      const _Tp*
-      _M_ptr() const noexcept
-      { return static_cast<const _Tp*>(_M_addr()); }
-    };
-
-
-
-
-
-
-  template<typename _Tp>
-    struct __aligned_buffer
-    : std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>
-    {
-      typename
- std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>::type
- _M_storage;
-
-      __aligned_buffer() = default;
-
-
-      __aligned_buffer(std::nullptr_t) { }
-
-      void*
-      _M_addr() noexcept
-      {
-        return static_cast<void*>(&_M_storage);
-      }
-
-      const void*
-      _M_addr() const noexcept
-      {
-        return static_cast<const void*>(&_M_storage);
-      }
-
-      _Tp*
-      _M_ptr() noexcept
-      { return static_cast<_Tp*>(_M_addr()); }
-
-      const _Tp*
-      _M_ptr() const noexcept
-      { return static_cast<const _Tp*>(_M_addr()); }
-    };
-
-}
-# 70 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 2 3
-
-
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-# 99 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-  enum _Rb_tree_color { _S_red = false, _S_black = true };
-
-  struct _Rb_tree_node_base
-  {
-    typedef _Rb_tree_node_base* _Base_ptr;
-    typedef const _Rb_tree_node_base* _Const_Base_ptr;
-
-    _Rb_tree_color _M_color;
-    _Base_ptr _M_parent;
-    _Base_ptr _M_left;
-    _Base_ptr _M_right;
-
-    static _Base_ptr
-    _S_minimum(_Base_ptr __x) noexcept
-    {
-      while (__x->_M_left != 0) __x = __x->_M_left;
-      return __x;
-    }
-
-    static _Const_Base_ptr
-    _S_minimum(_Const_Base_ptr __x) noexcept
-    {
-      while (__x->_M_left != 0) __x = __x->_M_left;
-      return __x;
-    }
-
-    static _Base_ptr
-    _S_maximum(_Base_ptr __x) noexcept
-    {
-      while (__x->_M_right != 0) __x = __x->_M_right;
-      return __x;
-    }
-
-    static _Const_Base_ptr
-    _S_maximum(_Const_Base_ptr __x) noexcept
-    {
-      while (__x->_M_right != 0) __x = __x->_M_right;
-      return __x;
-    }
-  };
-
-
-  template<typename _Key_compare>
-    struct _Rb_tree_key_compare
-    {
-      _Key_compare _M_key_compare;
-
-      _Rb_tree_key_compare()
-      noexcept(is_nothrow_default_constructible<_Key_compare>::value)
-
-      : _M_key_compare()
-      { }
-
-      _Rb_tree_key_compare(const _Key_compare& __comp)
-      : _M_key_compare(__comp)
-      { }
-
-
-
-      _Rb_tree_key_compare(const _Rb_tree_key_compare&) = default;
-
-      _Rb_tree_key_compare(_Rb_tree_key_compare&& __x)
- noexcept(is_nothrow_copy_constructible<_Key_compare>::value)
-      : _M_key_compare(__x._M_key_compare)
-      { }
-
-    };
-
-
-  struct _Rb_tree_header
-  {
-    _Rb_tree_node_base _M_header;
-    size_t _M_node_count;
-
-    _Rb_tree_header() noexcept
-    {
-      _M_header._M_color = _S_red;
-      _M_reset();
-    }
-
-
-    _Rb_tree_header(_Rb_tree_header&& __x) noexcept
-    {
-      if (__x._M_header._M_parent != nullptr)
- _M_move_data(__x);
-      else
- {
-   _M_header._M_color = _S_red;
-   _M_reset();
- }
-    }
-
-
-    void
-    _M_move_data(_Rb_tree_header& __from)
-    {
-      _M_header._M_color = __from._M_header._M_color;
-      _M_header._M_parent = __from._M_header._M_parent;
-      _M_header._M_left = __from._M_header._M_left;
-      _M_header._M_right = __from._M_header._M_right;
-      _M_header._M_parent->_M_parent = &_M_header;
-      _M_node_count = __from._M_node_count;
-
-      __from._M_reset();
-    }
-
-    void
-    _M_reset()
-    {
-      _M_header._M_parent = 0;
-      _M_header._M_left = &_M_header;
-      _M_header._M_right = &_M_header;
-      _M_node_count = 0;
-    }
-  };
-
-  template<typename _Val>
-    struct _Rb_tree_node : public _Rb_tree_node_base
-    {
-      typedef _Rb_tree_node<_Val>* _Link_type;
-# 231 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-      __gnu_cxx::__aligned_membuf<_Val> _M_storage;
-
-      _Val*
-      _M_valptr()
-      { return _M_storage._M_ptr(); }
-
-      const _Val*
-      _M_valptr() const
-      { return _M_storage._M_ptr(); }
-
-    };
-
-  __attribute__ ((__pure__)) _Rb_tree_node_base*
-  _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
-
-  __attribute__ ((__pure__)) const _Rb_tree_node_base*
-  _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();
-
-  __attribute__ ((__pure__)) _Rb_tree_node_base*
-  _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
-
-  __attribute__ ((__pure__)) const _Rb_tree_node_base*
-  _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();
-
-  template<typename _Tp>
-    struct _Rb_tree_iterator
-    {
-      typedef _Tp value_type;
-      typedef _Tp& reference;
-      typedef _Tp* pointer;
-
-      typedef bidirectional_iterator_tag iterator_category;
-      typedef ptrdiff_t difference_type;
-
-      typedef _Rb_tree_iterator<_Tp> _Self;
-      typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
-      typedef _Rb_tree_node<_Tp>* _Link_type;
-
-      _Rb_tree_iterator() noexcept
-      : _M_node() { }
-
-      explicit
-      _Rb_tree_iterator(_Base_ptr __x) noexcept
-      : _M_node(__x) { }
-
-      reference
-      operator*() const noexcept
-      { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
-
-      pointer
-      operator->() const noexcept
-      { return static_cast<_Link_type> (_M_node)->_M_valptr(); }
-
-      _Self&
-      operator++() noexcept
-      {
- _M_node = _Rb_tree_increment(_M_node);
- return *this;
-      }
-
-      _Self
-      operator++(int) noexcept
-      {
- _Self __tmp = *this;
- _M_node = _Rb_tree_increment(_M_node);
- return __tmp;
-      }
-
-      _Self&
-      operator--() noexcept
-      {
- _M_node = _Rb_tree_decrement(_M_node);
- return *this;
-      }
-
-      _Self
-      operator--(int) noexcept
-      {
- _Self __tmp = *this;
- _M_node = _Rb_tree_decrement(_M_node);
- return __tmp;
-      }
-
-      bool
-      operator==(const _Self& __x) const noexcept
-      { return _M_node == __x._M_node; }
-
-      bool
-      operator!=(const _Self& __x) const noexcept
-      { return _M_node != __x._M_node; }
-
-      _Base_ptr _M_node;
-  };
-
-  template<typename _Tp>
-    struct _Rb_tree_const_iterator
-    {
-      typedef _Tp value_type;
-      typedef const _Tp& reference;
-      typedef const _Tp* pointer;
-
-      typedef _Rb_tree_iterator<_Tp> iterator;
-
-      typedef bidirectional_iterator_tag iterator_category;
-      typedef ptrdiff_t difference_type;
-
-      typedef _Rb_tree_const_iterator<_Tp> _Self;
-      typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
-      typedef const _Rb_tree_node<_Tp>* _Link_type;
-
-      _Rb_tree_const_iterator() noexcept
-      : _M_node() { }
-
-      explicit
-      _Rb_tree_const_iterator(_Base_ptr __x) noexcept
-      : _M_node(__x) { }
-
-      _Rb_tree_const_iterator(const iterator& __it) noexcept
-      : _M_node(__it._M_node) { }
-
-      iterator
-      _M_const_cast() const noexcept
-      { return iterator(const_cast<typename iterator::_Base_ptr>(_M_node)); }
-
-      reference
-      operator*() const noexcept
-      { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
-
-      pointer
-      operator->() const noexcept
-      { return static_cast<_Link_type>(_M_node)->_M_valptr(); }
-
-      _Self&
-      operator++() noexcept
-      {
- _M_node = _Rb_tree_increment(_M_node);
- return *this;
-      }
-
-      _Self
-      operator++(int) noexcept
-      {
- _Self __tmp = *this;
- _M_node = _Rb_tree_increment(_M_node);
- return __tmp;
-      }
-
-      _Self&
-      operator--() noexcept
-      {
- _M_node = _Rb_tree_decrement(_M_node);
- return *this;
-      }
-
-      _Self
-      operator--(int) noexcept
-      {
- _Self __tmp = *this;
- _M_node = _Rb_tree_decrement(_M_node);
- return __tmp;
-      }
-
-      bool
-      operator==(const _Self& __x) const noexcept
-      { return _M_node == __x._M_node; }
-
-      bool
-      operator!=(const _Self& __x) const noexcept
-      { return _M_node != __x._M_node; }
-
-      _Base_ptr _M_node;
-    };
-
-  template<typename _Val>
-    inline bool
-    operator==(const _Rb_tree_iterator<_Val>& __x,
-        const _Rb_tree_const_iterator<_Val>& __y) noexcept
-    { return __x._M_node == __y._M_node; }
-
-  template<typename _Val>
-    inline bool
-    operator!=(const _Rb_tree_iterator<_Val>& __x,
-        const _Rb_tree_const_iterator<_Val>& __y) noexcept
-    { return __x._M_node != __y._M_node; }
-
-  void
-  _Rb_tree_insert_and_rebalance(const bool __insert_left,
-    _Rb_tree_node_base* __x,
-    _Rb_tree_node_base* __p,
-    _Rb_tree_node_base& __header) throw ();
-
-  _Rb_tree_node_base*
-  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
-          _Rb_tree_node_base& __header) throw ();
-
-
-  template<typename _Cmp, typename _SfinaeType, typename = __void_t<>>
-    struct __has_is_transparent
-    { };
-
-  template<typename _Cmp, typename _SfinaeType>
-    struct __has_is_transparent<_Cmp, _SfinaeType,
-    __void_t<typename _Cmp::is_transparent>>
-    { typedef void type; };
-
-
-
-
-
-
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc = allocator<_Val> >
-    class _Rb_tree
-    {
-      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
- rebind<_Rb_tree_node<_Val> >::other _Node_allocator;
-
-      typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits;
-
-
-      static_assert(__is_invocable<_Compare&, const _Key&, const _Key&>{},
-   "comparison object must be invocable with two arguments of key type");
-# 462 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-    protected:
-      typedef _Rb_tree_node_base* _Base_ptr;
-      typedef const _Rb_tree_node_base* _Const_Base_ptr;
-      typedef _Rb_tree_node<_Val>* _Link_type;
-      typedef const _Rb_tree_node<_Val>* _Const_Link_type;
-
-    private:
-
-
-      struct _Reuse_or_alloc_node
-      {
- _Reuse_or_alloc_node(_Rb_tree& __t)
-   : _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t)
- {
-   if (_M_root)
-     {
-       _M_root->_M_parent = 0;
-
-       if (_M_nodes->_M_left)
-  _M_nodes = _M_nodes->_M_left;
-     }
-   else
-     _M_nodes = 0;
- }
-
-
- _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;
-
-
- ~_Reuse_or_alloc_node()
- { _M_t._M_erase(static_cast<_Link_type>(_M_root)); }
-
- template<typename _Arg>
-   _Link_type
-
-
-
-   operator()(_Arg&& __arg)
-
-   {
-     _Link_type __node = static_cast<_Link_type>(_M_extract());
-     if (__node)
-       {
-  _M_t._M_destroy_node(__node);
-  _M_t._M_construct_node(__node, std::forward<_Arg>(__arg));
-  return __node;
-       }
-
-     return _M_t._M_create_node(std::forward<_Arg>(__arg));
-   }
-
-      private:
- _Base_ptr
- _M_extract()
- {
-   if (!_M_nodes)
-     return _M_nodes;
-
-   _Base_ptr __node = _M_nodes;
-   _M_nodes = _M_nodes->_M_parent;
-   if (_M_nodes)
-     {
-       if (_M_nodes->_M_right == __node)
-  {
-    _M_nodes->_M_right = 0;
-
-    if (_M_nodes->_M_left)
-      {
-        _M_nodes = _M_nodes->_M_left;
-
-        while (_M_nodes->_M_right)
-   _M_nodes = _M_nodes->_M_right;
-
-        if (_M_nodes->_M_left)
-   _M_nodes = _M_nodes->_M_left;
-      }
-  }
-       else
-  _M_nodes->_M_left = 0;
-     }
-   else
-     _M_root = 0;
-
-   return __node;
- }
-
- _Base_ptr _M_root;
- _Base_ptr _M_nodes;
- _Rb_tree& _M_t;
-      };
-
-
-
-      struct _Alloc_node
-      {
- _Alloc_node(_Rb_tree& __t)
-   : _M_t(__t) { }
-
- template<typename _Arg>
-   _Link_type
-
-
-
-   operator()(_Arg&& __arg) const
-
-   { return _M_t._M_create_node(std::forward<_Arg>(__arg)); }
-
-      private:
- _Rb_tree& _M_t;
-      };
-
-    public:
-      typedef _Key key_type;
-      typedef _Val value_type;
-      typedef value_type* pointer;
-      typedef const value_type* const_pointer;
-      typedef value_type& reference;
-      typedef const value_type& const_reference;
-      typedef size_t size_type;
-      typedef ptrdiff_t difference_type;
-      typedef _Alloc allocator_type;
-
-      _Node_allocator&
-      _M_get_Node_allocator() noexcept
-      { return this->_M_impl; }
-
-      const _Node_allocator&
-      _M_get_Node_allocator() const noexcept
-      { return this->_M_impl; }
-
-      allocator_type
-      get_allocator() const noexcept
-      { return allocator_type(_M_get_Node_allocator()); }
-
-    protected:
-      _Link_type
-      _M_get_node()
-      { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); }
-
-      void
-      _M_put_node(_Link_type __p) noexcept
-      { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); }
-# 630 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-      template<typename... _Args>
- void
- _M_construct_node(_Link_type __node, _Args&&... __args)
- {
-   try
-     {
-       ::new(__node) _Rb_tree_node<_Val>;
-       _Alloc_traits::construct(_M_get_Node_allocator(),
-           __node->_M_valptr(),
-           std::forward<_Args>(__args)...);
-     }
-   catch(...)
-     {
-       __node->~_Rb_tree_node<_Val>();
-       _M_put_node(__node);
-       throw;
-     }
- }
-
-      template<typename... _Args>
- _Link_type
- _M_create_node(_Args&&... __args)
- {
-   _Link_type __tmp = _M_get_node();
-   _M_construct_node(__tmp, std::forward<_Args>(__args)...);
-   return __tmp;
- }
-
-      void
-      _M_destroy_node(_Link_type __p) noexcept
-      {
- _Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
- __p->~_Rb_tree_node<_Val>();
-      }
-
-
-      void
-      _M_drop_node(_Link_type __p) noexcept
-      {
- _M_destroy_node(__p);
- _M_put_node(__p);
-      }
-
-      template<typename _NodeGen>
- _Link_type
- _M_clone_node(_Const_Link_type __x, _NodeGen& __node_gen)
- {
-   _Link_type __tmp = __node_gen(*__x->_M_valptr());
-   __tmp->_M_color = __x->_M_color;
-   __tmp->_M_left = 0;
-   __tmp->_M_right = 0;
-   return __tmp;
- }
-
-    protected:
-
-
-
-
-      template<typename _Key_compare,
-        bool = __is_pod(_Key_compare)>
-
- struct _Rb_tree_impl
- : public _Node_allocator
- , public _Rb_tree_key_compare<_Key_compare>
- , public _Rb_tree_header
- {
-   typedef _Rb_tree_key_compare<_Key_compare> _Base_key_compare;
-
-   _Rb_tree_impl()
-     noexcept(is_nothrow_default_constructible<_Node_allocator>::value && is_nothrow_default_constructible<_Base_key_compare>::value)
-
-
-   : _Node_allocator()
-   { }
-
-   _Rb_tree_impl(const _Rb_tree_impl& __x)
-   : _Node_allocator(_Alloc_traits::_S_select_on_copy(__x))
-   , _Base_key_compare(__x._M_key_compare)
-   { }
-
-
-
-
-
-
-   _Rb_tree_impl(_Rb_tree_impl&&) = default;
-
-   _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
-   : _Node_allocator(std::move(__a)), _Base_key_compare(__comp)
-   { }
-
- };
-
-      _Rb_tree_impl<_Compare> _M_impl;
-
-    protected:
-      _Base_ptr&
-      _M_root() noexcept
-      { return this->_M_impl._M_header._M_parent; }
-
-      _Const_Base_ptr
-      _M_root() const noexcept
-      { return this->_M_impl._M_header._M_parent; }
-
-      _Base_ptr&
-      _M_leftmost() noexcept
-      { return this->_M_impl._M_header._M_left; }
-
-      _Const_Base_ptr
-      _M_leftmost() const noexcept
-      { return this->_M_impl._M_header._M_left; }
-
-      _Base_ptr&
-      _M_rightmost() noexcept
-      { return this->_M_impl._M_header._M_right; }
-
-      _Const_Base_ptr
-      _M_rightmost() const noexcept
-      { return this->_M_impl._M_header._M_right; }
-
-      _Link_type
-      _M_begin() noexcept
-      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
-
-      _Const_Link_type
-      _M_begin() const noexcept
-      {
- return static_cast<_Const_Link_type>
-   (this->_M_impl._M_header._M_parent);
-      }
-
-      _Base_ptr
-      _M_end() noexcept
-      { return &this->_M_impl._M_header; }
-
-      _Const_Base_ptr
-      _M_end() const noexcept
-      { return &this->_M_impl._M_header; }
-
-      static const_reference
-      _S_value(_Const_Link_type __x)
-      { return *__x->_M_valptr(); }
-
-      static const _Key&
-      _S_key(_Const_Link_type __x)
-      { return _KeyOfValue()(_S_value(__x)); }
-
-      static _Link_type
-      _S_left(_Base_ptr __x) noexcept
-      { return static_cast<_Link_type>(__x->_M_left); }
-
-      static _Const_Link_type
-      _S_left(_Const_Base_ptr __x) noexcept
-      { return static_cast<_Const_Link_type>(__x->_M_left); }
-
-      static _Link_type
-      _S_right(_Base_ptr __x) noexcept
-      { return static_cast<_Link_type>(__x->_M_right); }
-
-      static _Const_Link_type
-      _S_right(_Const_Base_ptr __x) noexcept
-      { return static_cast<_Const_Link_type>(__x->_M_right); }
-
-      static const_reference
-      _S_value(_Const_Base_ptr __x)
-      { return *static_cast<_Const_Link_type>(__x)->_M_valptr(); }
-
-      static const _Key&
-      _S_key(_Const_Base_ptr __x)
-      { return _KeyOfValue()(_S_value(__x)); }
-
-      static _Base_ptr
-      _S_minimum(_Base_ptr __x) noexcept
-      { return _Rb_tree_node_base::_S_minimum(__x); }
-
-      static _Const_Base_ptr
-      _S_minimum(_Const_Base_ptr __x) noexcept
-      { return _Rb_tree_node_base::_S_minimum(__x); }
-
-      static _Base_ptr
-      _S_maximum(_Base_ptr __x) noexcept
-      { return _Rb_tree_node_base::_S_maximum(__x); }
-
-      static _Const_Base_ptr
-      _S_maximum(_Const_Base_ptr __x) noexcept
-      { return _Rb_tree_node_base::_S_maximum(__x); }
-
-    public:
-      typedef _Rb_tree_iterator<value_type> iterator;
-      typedef _Rb_tree_const_iterator<value_type> const_iterator;
-
-      typedef std::reverse_iterator<iterator> reverse_iterator;
-      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-# 832 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-      pair<_Base_ptr, _Base_ptr>
-      _M_get_insert_unique_pos(const key_type& __k);
-
-      pair<_Base_ptr, _Base_ptr>
-      _M_get_insert_equal_pos(const key_type& __k);
-
-      pair<_Base_ptr, _Base_ptr>
-      _M_get_insert_hint_unique_pos(const_iterator __pos,
-        const key_type& __k);
-
-      pair<_Base_ptr, _Base_ptr>
-      _M_get_insert_hint_equal_pos(const_iterator __pos,
-       const key_type& __k);
-
-    private:
-
-      template<typename _Arg, typename _NodeGen>
- iterator
- _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&);
-
-      iterator
-      _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z);
-
-      template<typename _Arg>
- iterator
- _M_insert_lower(_Base_ptr __y, _Arg&& __v);
-
-      template<typename _Arg>
- iterator
- _M_insert_equal_lower(_Arg&& __x);
-
-      iterator
-      _M_insert_lower_node(_Base_ptr __p, _Link_type __z);
-
-      iterator
-      _M_insert_equal_lower_node(_Link_type __z);
-# 883 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-      template<typename _NodeGen>
- _Link_type
- _M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen&);
-
-      template<typename _NodeGen>
- _Link_type
- _M_copy(const _Rb_tree& __x, _NodeGen& __gen)
- {
-   _Link_type __root = _M_copy(__x._M_begin(), _M_end(), __gen);
-   _M_leftmost() = _S_minimum(__root);
-   _M_rightmost() = _S_maximum(__root);
-   _M_impl._M_node_count = __x._M_impl._M_node_count;
-   return __root;
- }
-
-      _Link_type
-      _M_copy(const _Rb_tree& __x)
-      {
- _Alloc_node __an(*this);
- return _M_copy(__x, __an);
-      }
-
-      void
-      _M_erase(_Link_type __x);
-
-      iterator
-      _M_lower_bound(_Link_type __x, _Base_ptr __y,
-       const _Key& __k);
-
-      const_iterator
-      _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
-       const _Key& __k) const;
-
-      iterator
-      _M_upper_bound(_Link_type __x, _Base_ptr __y,
-       const _Key& __k);
-
-      const_iterator
-      _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
-       const _Key& __k) const;
-
-    public:
-
-
-
-
-      _Rb_tree() = default;
-
-
-      _Rb_tree(const _Compare& __comp,
-        const allocator_type& __a = allocator_type())
-      : _M_impl(__comp, _Node_allocator(__a)) { }
-
-      _Rb_tree(const _Rb_tree& __x)
-      : _M_impl(__x._M_impl)
-      {
- if (__x._M_root() != 0)
-   _M_root() = _M_copy(__x);
-      }
-
-
-      _Rb_tree(const allocator_type& __a)
-      : _M_impl(_Compare(), _Node_allocator(__a))
-      { }
-
-      _Rb_tree(const _Rb_tree& __x, const allocator_type& __a)
-      : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a))
-      {
- if (__x._M_root() != nullptr)
-   _M_root() = _M_copy(__x);
-      }
-
-      _Rb_tree(_Rb_tree&&) = default;
-
-      _Rb_tree(_Rb_tree&& __x, const allocator_type& __a)
-      : _Rb_tree(std::move(__x), _Node_allocator(__a))
-      { }
-
-      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a);
-
-
-      ~_Rb_tree() noexcept
-      { _M_erase(_M_begin()); }
-
-      _Rb_tree&
-      operator=(const _Rb_tree& __x);
-
-
-      _Compare
-      key_comp() const
-      { return _M_impl._M_key_compare; }
-
-      iterator
-      begin() noexcept
-      { return iterator(this->_M_impl._M_header._M_left); }
-
-      const_iterator
-      begin() const noexcept
-      { return const_iterator(this->_M_impl._M_header._M_left); }
-
-      iterator
-      end() noexcept
-      { return iterator(&this->_M_impl._M_header); }
-
-      const_iterator
-      end() const noexcept
-      { return const_iterator(&this->_M_impl._M_header); }
-
-      reverse_iterator
-      rbegin() noexcept
-      { return reverse_iterator(end()); }
-
-      const_reverse_iterator
-      rbegin() const noexcept
-      { return const_reverse_iterator(end()); }
-
-      reverse_iterator
-      rend() noexcept
-      { return reverse_iterator(begin()); }
-
-      const_reverse_iterator
-      rend() const noexcept
-      { return const_reverse_iterator(begin()); }
-
-      bool
-      empty() const noexcept
-      { return _M_impl._M_node_count == 0; }
-
-      size_type
-      size() const noexcept
-      { return _M_impl._M_node_count; }
-
-      size_type
-      max_size() const noexcept
-      { return _Alloc_traits::max_size(_M_get_Node_allocator()); }
-
-      void
-      swap(_Rb_tree& __t)
-      noexcept(__is_nothrow_swappable<_Compare>::value);
-
-
-
-      template<typename _Arg>
- pair<iterator, bool>
- _M_insert_unique(_Arg&& __x);
-
-      template<typename _Arg>
- iterator
- _M_insert_equal(_Arg&& __x);
-
-      template<typename _Arg, typename _NodeGen>
- iterator
- _M_insert_unique_(const_iterator __pos, _Arg&& __x, _NodeGen&);
-
-      template<typename _Arg>
- iterator
- _M_insert_unique_(const_iterator __pos, _Arg&& __x)
- {
-   _Alloc_node __an(*this);
-   return _M_insert_unique_(__pos, std::forward<_Arg>(__x), __an);
- }
-
-      template<typename _Arg, typename _NodeGen>
- iterator
- _M_insert_equal_(const_iterator __pos, _Arg&& __x, _NodeGen&);
-
-      template<typename _Arg>
- iterator
- _M_insert_equal_(const_iterator __pos, _Arg&& __x)
- {
-   _Alloc_node __an(*this);
-   return _M_insert_equal_(__pos, std::forward<_Arg>(__x), __an);
- }
-
-      template<typename... _Args>
- pair<iterator, bool>
- _M_emplace_unique(_Args&&... __args);
-
-      template<typename... _Args>
- iterator
- _M_emplace_equal(_Args&&... __args);
-
-      template<typename... _Args>
- iterator
- _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);
-
-      template<typename... _Args>
- iterator
- _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);
-# 1103 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-      template<typename _InputIterator>
- void
- _M_insert_unique(_InputIterator __first, _InputIterator __last);
-
-      template<typename _InputIterator>
- void
- _M_insert_equal(_InputIterator __first, _InputIterator __last);
-
-    private:
-      void
-      _M_erase_aux(const_iterator __position);
-
-      void
-      _M_erase_aux(const_iterator __first, const_iterator __last);
-
-    public:
-
-
-
-      __attribute ((__abi_tag__ ("cxx11")))
-      iterator
-      erase(const_iterator __position)
-      {
- ;
- const_iterator __result = __position;
- ++__result;
- _M_erase_aux(__position);
- return __result._M_const_cast();
-      }
-
-
-      __attribute ((__abi_tag__ ("cxx11")))
-      iterator
-      erase(iterator __position)
-      {
- ;
- iterator __result = __position;
- ++__result;
- _M_erase_aux(__position);
- return __result;
-      }
-# 1159 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-      size_type
-      erase(const key_type& __x);
-
-
-
-
-      __attribute ((__abi_tag__ ("cxx11")))
-      iterator
-      erase(const_iterator __first, const_iterator __last)
-      {
- _M_erase_aux(__first, __last);
- return __last._M_const_cast();
-      }
-# 1181 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-      void
-      erase(const key_type* __first, const key_type* __last);
-
-      void
-      clear() noexcept
-      {
- _M_erase(_M_begin());
- _M_impl._M_reset();
-      }
-
-
-      iterator
-      find(const key_type& __k);
-
-      const_iterator
-      find(const key_type& __k) const;
-
-      size_type
-      count(const key_type& __k) const;
-
-      iterator
-      lower_bound(const key_type& __k)
-      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
-
-      const_iterator
-      lower_bound(const key_type& __k) const
-      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
-
-      iterator
-      upper_bound(const key_type& __k)
-      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
-
-      const_iterator
-      upper_bound(const key_type& __k) const
-      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
-
-      pair<iterator, iterator>
-      equal_range(const key_type& __k);
-
-      pair<const_iterator, const_iterator>
-      equal_range(const key_type& __k) const;
-
-
-      template<typename _Kt,
-        typename _Req =
-   typename __has_is_transparent<_Compare, _Kt>::type>
- iterator
- _M_find_tr(const _Kt& __k)
- {
-   const _Rb_tree* __const_this = this;
-   return __const_this->_M_find_tr(__k)._M_const_cast();
- }
-
-      template<typename _Kt,
-        typename _Req =
-   typename __has_is_transparent<_Compare, _Kt>::type>
- const_iterator
- _M_find_tr(const _Kt& __k) const
- {
-   auto __j = _M_lower_bound_tr(__k);
-   if (__j != end() && _M_impl._M_key_compare(__k, _S_key(__j._M_node)))
-     __j = end();
-   return __j;
- }
-
-      template<typename _Kt,
-        typename _Req =
-   typename __has_is_transparent<_Compare, _Kt>::type>
- size_type
- _M_count_tr(const _Kt& __k) const
- {
-   auto __p = _M_equal_range_tr(__k);
-   return std::distance(__p.first, __p.second);
- }
-
-      template<typename _Kt,
-        typename _Req =
-   typename __has_is_transparent<_Compare, _Kt>::type>
- iterator
- _M_lower_bound_tr(const _Kt& __k)
- {
-   const _Rb_tree* __const_this = this;
-   return __const_this->_M_lower_bound_tr(__k)._M_const_cast();
- }
-
-      template<typename _Kt,
-        typename _Req =
-   typename __has_is_transparent<_Compare, _Kt>::type>
- const_iterator
- _M_lower_bound_tr(const _Kt& __k) const
- {
-   auto __x = _M_begin();
-   auto __y = _M_end();
-   while (__x != 0)
-     if (!_M_impl._M_key_compare(_S_key(__x), __k))
-       {
-  __y = __x;
-  __x = _S_left(__x);
-       }
-     else
-       __x = _S_right(__x);
-   return const_iterator(__y);
- }
-
-      template<typename _Kt,
-        typename _Req =
-   typename __has_is_transparent<_Compare, _Kt>::type>
- iterator
- _M_upper_bound_tr(const _Kt& __k)
- {
-   const _Rb_tree* __const_this = this;
-   return __const_this->_M_upper_bound_tr(__k)._M_const_cast();
- }
-
-      template<typename _Kt,
-        typename _Req =
-   typename __has_is_transparent<_Compare, _Kt>::type>
- const_iterator
- _M_upper_bound_tr(const _Kt& __k) const
- {
-   auto __x = _M_begin();
-   auto __y = _M_end();
-   while (__x != 0)
-     if (_M_impl._M_key_compare(__k, _S_key(__x)))
-       {
-  __y = __x;
-  __x = _S_left(__x);
-       }
-     else
-       __x = _S_right(__x);
-   return const_iterator(__y);
- }
-
-      template<typename _Kt,
-        typename _Req =
-   typename __has_is_transparent<_Compare, _Kt>::type>
- pair<iterator, iterator>
- _M_equal_range_tr(const _Kt& __k)
- {
-   const _Rb_tree* __const_this = this;
-   auto __ret = __const_this->_M_equal_range_tr(__k);
-   return { __ret.first._M_const_cast(), __ret.second._M_const_cast() };
- }
-
-      template<typename _Kt,
-        typename _Req =
-   typename __has_is_transparent<_Compare, _Kt>::type>
- pair<const_iterator, const_iterator>
- _M_equal_range_tr(const _Kt& __k) const
- {
-   auto __low = _M_lower_bound_tr(__k);
-   auto __high = __low;
-   auto& __cmp = _M_impl._M_key_compare;
-   while (__high != end() && !__cmp(__k, _S_key(__high._M_node)))
-     ++__high;
-   return { __low, __high };
- }
-
-
-
-      bool
-      __rb_verify() const;
-
-
-      _Rb_tree&
-      operator=(_Rb_tree&&)
-      noexcept(_Alloc_traits::_S_nothrow_move()
-        && is_nothrow_move_assignable<_Compare>::value);
-
-      template<typename _Iterator>
- void
- _M_assign_unique(_Iterator, _Iterator);
-
-      template<typename _Iterator>
- void
- _M_assign_equal(_Iterator, _Iterator);
-
-    private:
-
-      void
-      _M_move_data(_Rb_tree& __x, std::true_type)
-      { _M_impl._M_move_data(__x._M_impl); }
-
-
-
-      void
-      _M_move_data(_Rb_tree&, std::false_type);
-
-
-      void
-      _M_move_assign(_Rb_tree&, std::true_type);
-
-
-
-      void
-      _M_move_assign(_Rb_tree&, std::false_type);
-# 1544 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-    };
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    inline bool
-    operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
-        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
-    {
-      return __x.size() == __y.size()
-      && std::equal(__x.begin(), __x.end(), __y.begin());
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    inline bool
-    operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
-       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
-    {
-      return std::lexicographical_compare(__x.begin(), __x.end(),
-       __y.begin(), __y.end());
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    inline bool
-    operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
-        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
-    { return !(__x == __y); }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    inline bool
-    operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
-       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
-    { return __y < __x; }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    inline bool
-    operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
-        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
-    { return !(__y < __x); }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    inline bool
-    operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
-        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
-    { return !(__x < __y); }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    inline void
-    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
-  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
-    { __x.swap(__y); }
-
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
-    : _M_impl(__x._M_impl._M_key_compare, std::move(__a))
-    {
-      using __eq = typename _Alloc_traits::is_always_equal;
-      if (__x._M_root() != nullptr)
- _M_move_data(__x, __eq());
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    void
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_move_data(_Rb_tree& __x, std::false_type)
-    {
-      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
- _M_move_data(__x, std::true_type());
-      else
- {
-   _Alloc_node __an(*this);
-   auto __lbd =
-     [&__an](const value_type& __cval)
-     {
-       auto& __val = const_cast<value_type&>(__cval);
-       return __an(std::move_if_noexcept(__val));
-     };
-   _M_root() = _M_copy(__x, __lbd);
- }
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    inline void
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_move_assign(_Rb_tree& __x, true_type)
-    {
-      clear();
-      if (__x._M_root() != nullptr)
- _M_move_data(__x, std::true_type());
-      std::__alloc_on_move(_M_get_Node_allocator(),
-      __x._M_get_Node_allocator());
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    void
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_move_assign(_Rb_tree& __x, false_type)
-    {
-      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
- return _M_move_assign(__x, true_type{});
-
-
-
-      _Reuse_or_alloc_node __roan(*this);
-      _M_impl._M_reset();
-      if (__x._M_root() != nullptr)
- {
-   auto __lbd =
-     [&__roan](const value_type& __cval)
-     {
-       auto& __val = const_cast<value_type&>(__cval);
-       return __roan(std::move_if_noexcept(__val));
-     };
-   _M_root() = _M_copy(__x, __lbd);
-   __x.clear();
- }
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    operator=(_Rb_tree&& __x)
-    noexcept(_Alloc_traits::_S_nothrow_move()
-      && is_nothrow_move_assignable<_Compare>::value)
-    {
-      _M_impl._M_key_compare = std::move(__x._M_impl._M_key_compare);
-      _M_move_assign(__x, __bool_constant<_Alloc_traits::_S_nothrow_move()>());
-      return *this;
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    template<typename _Iterator>
-      void
-      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-      _M_assign_unique(_Iterator __first, _Iterator __last)
-      {
- _Reuse_or_alloc_node __roan(*this);
- _M_impl._M_reset();
- for (; __first != __last; ++__first)
-   _M_insert_unique_(end(), *__first, __roan);
-      }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    template<typename _Iterator>
-      void
-      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-      _M_assign_equal(_Iterator __first, _Iterator __last)
-      {
- _Reuse_or_alloc_node __roan(*this);
- _M_impl._M_reset();
- for (; __first != __last; ++__first)
-   _M_insert_equal_(end(), *__first, __roan);
-      }
-
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    operator=(const _Rb_tree& __x)
-    {
-      if (this != &__x)
- {
-
-
-   if (_Alloc_traits::_S_propagate_on_copy_assign())
-     {
-       auto& __this_alloc = this->_M_get_Node_allocator();
-       auto& __that_alloc = __x._M_get_Node_allocator();
-       if (!_Alloc_traits::_S_always_equal()
-    && __this_alloc != __that_alloc)
-  {
-
-
-    clear();
-    std::__alloc_on_copy(__this_alloc, __that_alloc);
-  }
-     }
-
-
-   _Reuse_or_alloc_node __roan(*this);
-   _M_impl._M_reset();
-   _M_impl._M_key_compare = __x._M_impl._M_key_compare;
-   if (__x._M_root() != 0)
-     _M_root() = _M_copy(__x, __roan);
- }
-
-      return *this;
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-
-    template<typename _Arg, typename _NodeGen>
-
-
-
-      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-      _M_insert_(_Base_ptr __x, _Base_ptr __p,
-
-   _Arg&& __v,
-
-
-
-   _NodeGen& __node_gen)
-      {
- bool __insert_left = (__x != 0 || __p == _M_end()
-         || _M_impl._M_key_compare(_KeyOfValue()(__v),
-       _S_key(__p)));
-
- _Link_type __z = __node_gen(std::forward<_Arg>(__v));
-
- _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
-          this->_M_impl._M_header);
- ++_M_impl._M_node_count;
- return iterator(__z);
-      }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-
-    template<typename _Arg>
-
-    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-
-    _M_insert_lower(_Base_ptr __p, _Arg&& __v)
-
-
-
-    {
-      bool __insert_left = (__p == _M_end()
-       || !_M_impl._M_key_compare(_S_key(__p),
-             _KeyOfValue()(__v)));
-
-      _Link_type __z = _M_create_node(std::forward<_Arg>(__v));
-
-      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
-        this->_M_impl._M_header);
-      ++_M_impl._M_node_count;
-      return iterator(__z);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-
-    template<typename _Arg>
-
-    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-
-    _M_insert_equal_lower(_Arg&& __v)
-
-
-
-    {
-      _Link_type __x = _M_begin();
-      _Base_ptr __y = _M_end();
-      while (__x != 0)
- {
-   __y = __x;
-   __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
-  _S_left(__x) : _S_right(__x);
- }
-      return _M_insert_lower(__y, std::forward<_Arg>(__v));
-    }
-
-  template<typename _Key, typename _Val, typename _KoV,
-    typename _Compare, typename _Alloc>
-    template<typename _NodeGen>
-      typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
-      _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
-      _M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen& __node_gen)
-      {
-
- _Link_type __top = _M_clone_node(__x, __node_gen);
- __top->_M_parent = __p;
-
- try
-   {
-     if (__x->_M_right)
-       __top->_M_right = _M_copy(_S_right(__x), __top, __node_gen);
-     __p = __top;
-     __x = _S_left(__x);
-
-     while (__x != 0)
-       {
-  _Link_type __y = _M_clone_node(__x, __node_gen);
-  __p->_M_left = __y;
-  __y->_M_parent = __p;
-  if (__x->_M_right)
-    __y->_M_right = _M_copy(_S_right(__x), __y, __node_gen);
-  __p = __y;
-  __x = _S_left(__x);
-       }
-   }
- catch(...)
-   {
-     _M_erase(__top);
-     throw;
-   }
- return __top;
-      }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    void
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_erase(_Link_type __x)
-    {
-
-      while (__x != 0)
- {
-   _M_erase(_S_right(__x));
-   _Link_type __y = _S_left(__x);
-   _M_drop_node(__x);
-   __x = __y;
- }
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue,
-        _Compare, _Alloc>::iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_lower_bound(_Link_type __x, _Base_ptr __y,
-     const _Key& __k)
-    {
-      while (__x != 0)
- if (!_M_impl._M_key_compare(_S_key(__x), __k))
-   __y = __x, __x = _S_left(__x);
- else
-   __x = _S_right(__x);
-      return iterator(__y);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue,
-        _Compare, _Alloc>::const_iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
-     const _Key& __k) const
-    {
-      while (__x != 0)
- if (!_M_impl._M_key_compare(_S_key(__x), __k))
-   __y = __x, __x = _S_left(__x);
- else
-   __x = _S_right(__x);
-      return const_iterator(__y);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue,
-        _Compare, _Alloc>::iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_upper_bound(_Link_type __x, _Base_ptr __y,
-     const _Key& __k)
-    {
-      while (__x != 0)
- if (_M_impl._M_key_compare(__k, _S_key(__x)))
-   __y = __x, __x = _S_left(__x);
- else
-   __x = _S_right(__x);
-      return iterator(__y);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue,
-        _Compare, _Alloc>::const_iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
-     const _Key& __k) const
-    {
-      while (__x != 0)
- if (_M_impl._M_key_compare(__k, _S_key(__x)))
-   __y = __x, __x = _S_left(__x);
- else
-   __x = _S_right(__x);
-      return const_iterator(__y);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::iterator,
-  typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::iterator>
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    equal_range(const _Key& __k)
-    {
-      _Link_type __x = _M_begin();
-      _Base_ptr __y = _M_end();
-      while (__x != 0)
- {
-   if (_M_impl._M_key_compare(_S_key(__x), __k))
-     __x = _S_right(__x);
-   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
-     __y = __x, __x = _S_left(__x);
-   else
-     {
-       _Link_type __xu(__x);
-       _Base_ptr __yu(__y);
-       __y = __x, __x = _S_left(__x);
-       __xu = _S_right(__xu);
-       return pair<iterator,
-     iterator>(_M_lower_bound(__x, __y, __k),
-        _M_upper_bound(__xu, __yu, __k));
-     }
- }
-      return pair<iterator, iterator>(iterator(__y),
-          iterator(__y));
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::const_iterator,
-  typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::const_iterator>
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    equal_range(const _Key& __k) const
-    {
-      _Const_Link_type __x = _M_begin();
-      _Const_Base_ptr __y = _M_end();
-      while (__x != 0)
- {
-   if (_M_impl._M_key_compare(_S_key(__x), __k))
-     __x = _S_right(__x);
-   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
-     __y = __x, __x = _S_left(__x);
-   else
-     {
-       _Const_Link_type __xu(__x);
-       _Const_Base_ptr __yu(__y);
-       __y = __x, __x = _S_left(__x);
-       __xu = _S_right(__xu);
-       return pair<const_iterator,
-     const_iterator>(_M_lower_bound(__x, __y, __k),
-       _M_upper_bound(__xu, __yu, __k));
-     }
- }
-      return pair<const_iterator, const_iterator>(const_iterator(__y),
-        const_iterator(__y));
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    void
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    swap(_Rb_tree& __t)
-    noexcept(__is_nothrow_swappable<_Compare>::value)
-    {
-      if (_M_root() == 0)
- {
-   if (__t._M_root() != 0)
-     _M_impl._M_move_data(__t._M_impl);
- }
-      else if (__t._M_root() == 0)
- __t._M_impl._M_move_data(_M_impl);
-      else
- {
-   std::swap(_M_root(),__t._M_root());
-   std::swap(_M_leftmost(),__t._M_leftmost());
-   std::swap(_M_rightmost(),__t._M_rightmost());
-
-   _M_root()->_M_parent = _M_end();
-   __t._M_root()->_M_parent = __t._M_end();
-   std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
- }
-
-      std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
-
-      _Alloc_traits::_S_on_swap(_M_get_Node_allocator(),
-    __t._M_get_Node_allocator());
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::_Base_ptr,
-  typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::_Base_ptr>
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_get_insert_unique_pos(const key_type& __k)
-    {
-      typedef pair<_Base_ptr, _Base_ptr> _Res;
-      _Link_type __x = _M_begin();
-      _Base_ptr __y = _M_end();
-      bool __comp = true;
-      while (__x != 0)
- {
-   __y = __x;
-   __comp = _M_impl._M_key_compare(__k, _S_key(__x));
-   __x = __comp ? _S_left(__x) : _S_right(__x);
- }
-      iterator __j = iterator(__y);
-      if (__comp)
- {
-   if (__j == begin())
-     return _Res(__x, __y);
-   else
-     --__j;
- }
-      if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
- return _Res(__x, __y);
-      return _Res(__j._M_node, 0);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::_Base_ptr,
-  typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::_Base_ptr>
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_get_insert_equal_pos(const key_type& __k)
-    {
-      typedef pair<_Base_ptr, _Base_ptr> _Res;
-      _Link_type __x = _M_begin();
-      _Base_ptr __y = _M_end();
-      while (__x != 0)
- {
-   __y = __x;
-   __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
-  _S_left(__x) : _S_right(__x);
- }
-      return _Res(__x, __y);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-
-    template<typename _Arg>
-
-    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::iterator, bool>
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-
-    _M_insert_unique(_Arg&& __v)
-
-
-
-    {
-      typedef pair<iterator, bool> _Res;
-      pair<_Base_ptr, _Base_ptr> __res
- = _M_get_insert_unique_pos(_KeyOfValue()(__v));
-
-      if (__res.second)
- {
-   _Alloc_node __an(*this);
-   return _Res(_M_insert_(__res.first, __res.second,
-     std::forward<_Arg>(__v), __an),
-        true);
- }
-
-      return _Res(iterator(__res.first), false);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-
-    template<typename _Arg>
-
-    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-
-    _M_insert_equal(_Arg&& __v)
-
-
-
-    {
-      pair<_Base_ptr, _Base_ptr> __res
- = _M_get_insert_equal_pos(_KeyOfValue()(__v));
-      _Alloc_node __an(*this);
-      return _M_insert_(__res.first, __res.second,
-   std::forward<_Arg>(__v), __an);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::_Base_ptr,
-  typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::_Base_ptr>
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_get_insert_hint_unique_pos(const_iterator __position,
-      const key_type& __k)
-    {
-      iterator __pos = __position._M_const_cast();
-      typedef pair<_Base_ptr, _Base_ptr> _Res;
-
-
-      if (__pos._M_node == _M_end())
- {
-   if (size() > 0
-       && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
-     return _Res(0, _M_rightmost());
-   else
-     return _M_get_insert_unique_pos(__k);
- }
-      else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
- {
-
-   iterator __before = __pos;
-   if (__pos._M_node == _M_leftmost())
-     return _Res(_M_leftmost(), _M_leftmost());
-   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
-     {
-       if (_S_right(__before._M_node) == 0)
-  return _Res(0, __before._M_node);
-       else
-  return _Res(__pos._M_node, __pos._M_node);
-     }
-   else
-     return _M_get_insert_unique_pos(__k);
- }
-      else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
- {
-
-   iterator __after = __pos;
-   if (__pos._M_node == _M_rightmost())
-     return _Res(0, _M_rightmost());
-   else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
-     {
-       if (_S_right(__pos._M_node) == 0)
-  return _Res(0, __pos._M_node);
-       else
-  return _Res(__after._M_node, __after._M_node);
-     }
-   else
-     return _M_get_insert_unique_pos(__k);
- }
-      else
-
- return _Res(__pos._M_node, 0);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-
-    template<typename _Arg, typename _NodeGen>
-
-
-
-      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-      _M_insert_unique_(const_iterator __position,
-
-   _Arg&& __v,
-
-
-
-   _NodeGen& __node_gen)
-    {
-      pair<_Base_ptr, _Base_ptr> __res
- = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));
-
-      if (__res.second)
- return _M_insert_(__res.first, __res.second,
-     std::forward<_Arg>(__v),
-     __node_gen);
-      return iterator(__res.first);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::_Base_ptr,
-  typename _Rb_tree<_Key, _Val, _KeyOfValue,
-      _Compare, _Alloc>::_Base_ptr>
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
-    {
-      iterator __pos = __position._M_const_cast();
-      typedef pair<_Base_ptr, _Base_ptr> _Res;
-
-
-      if (__pos._M_node == _M_end())
- {
-   if (size() > 0
-       && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
-     return _Res(0, _M_rightmost());
-   else
-     return _M_get_insert_equal_pos(__k);
- }
-      else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
- {
-
-   iterator __before = __pos;
-   if (__pos._M_node == _M_leftmost())
-     return _Res(_M_leftmost(), _M_leftmost());
-   else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
-     {
-       if (_S_right(__before._M_node) == 0)
-  return _Res(0, __before._M_node);
-       else
-  return _Res(__pos._M_node, __pos._M_node);
-     }
-   else
-     return _M_get_insert_equal_pos(__k);
- }
-      else
- {
-
-   iterator __after = __pos;
-   if (__pos._M_node == _M_rightmost())
-     return _Res(0, _M_rightmost());
-   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
-     {
-       if (_S_right(__pos._M_node) == 0)
-  return _Res(0, __pos._M_node);
-       else
-  return _Res(__after._M_node, __after._M_node);
-     }
-   else
-     return _Res(0, 0);
- }
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-
-    template<typename _Arg, typename _NodeGen>
-
-
-
-      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-      _M_insert_equal_(const_iterator __position,
-
-         _Arg&& __v,
-
-
-
-         _NodeGen& __node_gen)
-      {
- pair<_Base_ptr, _Base_ptr> __res
-   = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));
-
- if (__res.second)
-   return _M_insert_(__res.first, __res.second,
-       std::forward<_Arg>(__v),
-       __node_gen);
-
- return _M_insert_equal_lower(std::forward<_Arg>(__v));
-      }
-
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z)
-    {
-      bool __insert_left = (__x != 0 || __p == _M_end()
-       || _M_impl._M_key_compare(_S_key(__z),
-            _S_key(__p)));
-
-      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
-        this->_M_impl._M_header);
-      ++_M_impl._M_node_count;
-      return iterator(__z);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_insert_lower_node(_Base_ptr __p, _Link_type __z)
-    {
-      bool __insert_left = (__p == _M_end()
-       || !_M_impl._M_key_compare(_S_key(__p),
-             _S_key(__z)));
-
-      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
-        this->_M_impl._M_header);
-      ++_M_impl._M_node_count;
-      return iterator(__z);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_insert_equal_lower_node(_Link_type __z)
-    {
-      _Link_type __x = _M_begin();
-      _Base_ptr __y = _M_end();
-      while (__x != 0)
- {
-   __y = __x;
-   __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ?
-  _S_left(__x) : _S_right(__x);
- }
-      return _M_insert_lower_node(__y, __z);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    template<typename... _Args>
-      pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
-        _Compare, _Alloc>::iterator, bool>
-      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-      _M_emplace_unique(_Args&&... __args)
-      {
- _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
-
- try
-   {
-     typedef pair<iterator, bool> _Res;
-     auto __res = _M_get_insert_unique_pos(_S_key(__z));
-     if (__res.second)
-       return _Res(_M_insert_node(__res.first, __res.second, __z), true);
-
-     _M_drop_node(__z);
-     return _Res(iterator(__res.first), false);
-   }
- catch(...)
-   {
-     _M_drop_node(__z);
-     throw;
-   }
-      }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    template<typename... _Args>
-      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-      _M_emplace_equal(_Args&&... __args)
-      {
- _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
-
- try
-   {
-     auto __res = _M_get_insert_equal_pos(_S_key(__z));
-     return _M_insert_node(__res.first, __res.second, __z);
-   }
- catch(...)
-   {
-     _M_drop_node(__z);
-     throw;
-   }
-      }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    template<typename... _Args>
-      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-      _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args)
-      {
- _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
-
- try
-   {
-     auto __res = _M_get_insert_hint_unique_pos(__pos, _S_key(__z));
-
-     if (__res.second)
-       return _M_insert_node(__res.first, __res.second, __z);
-
-     _M_drop_node(__z);
-     return iterator(__res.first);
-   }
- catch(...)
-   {
-     _M_drop_node(__z);
-     throw;
-   }
-      }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    template<typename... _Args>
-      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
-      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-      _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args)
-      {
- _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
-
- try
-   {
-     auto __res = _M_get_insert_hint_equal_pos(__pos, _S_key(__z));
-
-     if (__res.second)
-       return _M_insert_node(__res.first, __res.second, __z);
-
-     return _M_insert_equal_lower_node(__z);
-   }
- catch(...)
-   {
-     _M_drop_node(__z);
-     throw;
-   }
-      }
-
-
-  template<typename _Key, typename _Val, typename _KoV,
-    typename _Cmp, typename _Alloc>
-    template<class _II>
-      void
-      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
-      _M_insert_unique(_II __first, _II __last)
-      {
- _Alloc_node __an(*this);
- for (; __first != __last; ++__first)
-   _M_insert_unique_(end(), *__first, __an);
-      }
-
-  template<typename _Key, typename _Val, typename _KoV,
-    typename _Cmp, typename _Alloc>
-    template<class _II>
-      void
-      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
-      _M_insert_equal(_II __first, _II __last)
-      {
- _Alloc_node __an(*this);
- for (; __first != __last; ++__first)
-   _M_insert_equal_(end(), *__first, __an);
-      }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    void
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_erase_aux(const_iterator __position)
-    {
-      _Link_type __y =
- static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
-    (const_cast<_Base_ptr>(__position._M_node),
-     this->_M_impl._M_header));
-      _M_drop_node(__y);
-      --_M_impl._M_node_count;
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    void
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    _M_erase_aux(const_iterator __first, const_iterator __last)
-    {
-      if (__first == begin() && __last == end())
- clear();
-      else
- while (__first != __last)
-   _M_erase_aux(__first++);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    erase(const _Key& __x)
-    {
-      pair<iterator, iterator> __p = equal_range(__x);
-      const size_type __old_size = size();
-      _M_erase_aux(__p.first, __p.second);
-      return __old_size - size();
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    void
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    erase(const _Key* __first, const _Key* __last)
-    {
-      while (__first != __last)
- erase(*__first++);
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue,
-        _Compare, _Alloc>::iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    find(const _Key& __k)
-    {
-      iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
-      return (__j == end()
-       || _M_impl._M_key_compare(__k,
-     _S_key(__j._M_node))) ? end() : __j;
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue,
-        _Compare, _Alloc>::const_iterator
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    find(const _Key& __k) const
-    {
-      const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
-      return (__j == end()
-       || _M_impl._M_key_compare(__k,
-     _S_key(__j._M_node))) ? end() : __j;
-    }
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
-    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
-    count(const _Key& __k) const
-    {
-      pair<const_iterator, const_iterator> __p = equal_range(__k);
-      const size_type __n = std::distance(__p.first, __p.second);
-      return __n;
-    }
-
-  __attribute__ ((__pure__)) unsigned int
-  _Rb_tree_black_count(const _Rb_tree_node_base* __node,
-         const _Rb_tree_node_base* __root) throw ();
-
-  template<typename _Key, typename _Val, typename _KeyOfValue,
-    typename _Compare, typename _Alloc>
-    bool
-    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
-    {
-      if (_M_impl._M_node_count == 0 || begin() == end())
- return _M_impl._M_node_count == 0 && begin() == end()
-        && this->_M_impl._M_header._M_left == _M_end()
-        && this->_M_impl._M_header._M_right == _M_end();
-
-      unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
-      for (const_iterator __it = begin(); __it != end(); ++__it)
- {
-   _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
-   _Const_Link_type __L = _S_left(__x);
-   _Const_Link_type __R = _S_right(__x);
-
-   if (__x->_M_color == _S_red)
-     if ((__L && __L->_M_color == _S_red)
-  || (__R && __R->_M_color == _S_red))
-       return false;
-
-   if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
-     return false;
-   if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
-     return false;
-
-   if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
-     return false;
- }
-
-      if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
- return false;
-      if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
- return false;
-      return true;
-    }
-# 2627 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_tree.h" 3
-
-}
-# 61 "../x86_64-pc-linux-gnu/libstdc++-v3/include/set" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 1 3
-# 61 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-# 1 "../../src/libstdc++-v3/libsupc++/initializer_list" 1 3
-# 33 "../../src/libstdc++-v3/libsupc++/initializer_list" 3
-       
-# 34 "../../src/libstdc++-v3/libsupc++/initializer_list" 3
-
-
-
-
-
-#pragma GCC visibility push(default)
-
-
-
-namespace std
-{
-
-  template<class _E>
-    class initializer_list
-    {
-    public:
-      typedef _E value_type;
-      typedef const _E& reference;
-      typedef const _E& const_reference;
-      typedef size_t size_type;
-      typedef const _E* iterator;
-      typedef const _E* const_iterator;
-
-    private:
-      iterator _M_array;
-      size_type _M_len;
-
-
-      constexpr initializer_list(const_iterator __a, size_type __l)
-      : _M_array(__a), _M_len(__l) { }
-
-    public:
-      constexpr initializer_list() noexcept
-      : _M_array(0), _M_len(0) { }
-
-
-      constexpr size_type
-      size() const noexcept { return _M_len; }
-
-
-      constexpr const_iterator
-      begin() const noexcept { return _M_array; }
-
-
-      constexpr const_iterator
-      end() const noexcept { return begin() + size(); }
-    };
-
-
-
-
-
-
-  template<class _Tp>
-    constexpr const _Tp*
-    begin(initializer_list<_Tp> __ils) noexcept
-    { return __ils.begin(); }
-
-
-
-
-
-
-  template<class _Tp>
-    constexpr const _Tp*
-    end(initializer_list<_Tp> __ils) noexcept
-    { return __ils.end(); }
-}
-
-#pragma GCC visibility pop
-# 62 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 2 3
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    class multiset;
-# 92 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-  template<typename _Key, typename _Compare = std::less<_Key>,
-    typename _Alloc = std::allocator<_Key> >
-    class set
-    {
-# 108 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      static_assert(is_same<typename remove_cv<_Key>::type, _Key>::value,
-   "std::set must have a non-const, non-volatile value_type");
-
-
-
-
-
-
-    public:
-
-
-
-      typedef _Key key_type;
-      typedef _Key value_type;
-      typedef _Compare key_compare;
-      typedef _Compare value_compare;
-      typedef _Alloc allocator_type;
-
-
-    private:
-      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
- rebind<_Key>::other _Key_alloc_type;
-
-      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
-         key_compare, _Key_alloc_type> _Rep_type;
-      _Rep_type _M_t;
-
-      typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits;
-
-    public:
-
-
-      typedef typename _Alloc_traits::pointer pointer;
-      typedef typename _Alloc_traits::const_pointer const_pointer;
-      typedef typename _Alloc_traits::reference reference;
-      typedef typename _Alloc_traits::const_reference const_reference;
-
-
-
-      typedef typename _Rep_type::const_iterator iterator;
-      typedef typename _Rep_type::const_iterator const_iterator;
-      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
-      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
-      typedef typename _Rep_type::size_type size_type;
-      typedef typename _Rep_type::difference_type difference_type;
-# 167 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      set() = default;
-
-
-
-
-
-
-
-      explicit
-      set(const _Compare& __comp,
-   const allocator_type& __a = allocator_type())
-      : _M_t(__comp, _Key_alloc_type(__a)) { }
-# 190 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      template<typename _InputIterator>
- set(_InputIterator __first, _InputIterator __last)
- : _M_t()
- { _M_t._M_insert_unique(__first, __last); }
-# 207 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      template<typename _InputIterator>
- set(_InputIterator __first, _InputIterator __last,
-     const _Compare& __comp,
-     const allocator_type& __a = allocator_type())
- : _M_t(__comp, _Key_alloc_type(__a))
- { _M_t._M_insert_unique(__first, __last); }
-# 223 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      set(const set&) = default;
-
-
-
-
-
-
-
-      set(set&&) = default;
-# 243 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      set(initializer_list<value_type> __l,
-   const _Compare& __comp = _Compare(),
-   const allocator_type& __a = allocator_type())
-      : _M_t(__comp, _Key_alloc_type(__a))
-      { _M_t._M_insert_unique(__l.begin(), __l.end()); }
-
-
-      explicit
-      set(const allocator_type& __a)
-      : _M_t(_Compare(), _Key_alloc_type(__a)) { }
-
-
-      set(const set& __x, const allocator_type& __a)
-      : _M_t(__x._M_t, _Key_alloc_type(__a)) { }
-
-
-      set(set&& __x, const allocator_type& __a)
-      noexcept(is_nothrow_copy_constructible<_Compare>::value
-        && _Alloc_traits::_S_always_equal())
-      : _M_t(std::move(__x._M_t), _Key_alloc_type(__a)) { }
-
-
-      set(initializer_list<value_type> __l, const allocator_type& __a)
-      : _M_t(_Compare(), _Key_alloc_type(__a))
-      { _M_t._M_insert_unique(__l.begin(), __l.end()); }
-
-
-      template<typename _InputIterator>
- set(_InputIterator __first, _InputIterator __last,
-     const allocator_type& __a)
- : _M_t(_Compare(), _Key_alloc_type(__a))
- { _M_t._M_insert_unique(__first, __last); }
-
-
-
-
-
-
-      ~set() = default;
-# 297 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      set&
-      operator=(const set&) = default;
-
-
-      set&
-      operator=(set&&) = default;
-# 315 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      set&
-      operator=(initializer_list<value_type> __l)
-      {
- _M_t._M_assign_unique(__l.begin(), __l.end());
- return *this;
-      }
-
-
-
-
-
-      key_compare
-      key_comp() const
-      { return _M_t.key_comp(); }
-
-      value_compare
-      value_comp() const
-      { return _M_t.key_comp(); }
-
-      allocator_type
-      get_allocator() const noexcept
-      { return allocator_type(_M_t.get_allocator()); }
-
-
-
-
-
-
-      iterator
-      begin() const noexcept
-      { return _M_t.begin(); }
-
-
-
-
-
-
-      iterator
-      end() const noexcept
-      { return _M_t.end(); }
-
-
-
-
-
-
-      reverse_iterator
-      rbegin() const noexcept
-      { return _M_t.rbegin(); }
-
-
-
-
-
-
-      reverse_iterator
-      rend() const noexcept
-      { return _M_t.rend(); }
-
-
-
-
-
-
-
-      iterator
-      cbegin() const noexcept
-      { return _M_t.begin(); }
-
-
-
-
-
-
-      iterator
-      cend() const noexcept
-      { return _M_t.end(); }
-
-
-
-
-
-
-      reverse_iterator
-      crbegin() const noexcept
-      { return _M_t.rbegin(); }
-
-
-
-
-
-
-      reverse_iterator
-      crend() const noexcept
-      { return _M_t.rend(); }
-
-
-
-      bool
-      empty() const noexcept
-      { return _M_t.empty(); }
-
-
-      size_type
-      size() const noexcept
-      { return _M_t.size(); }
-
-
-      size_type
-      max_size() const noexcept
-      { return _M_t.max_size(); }
-# 440 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      void
-      swap(set& __x)
-      noexcept(__is_nothrow_swappable<_Compare>::value)
-      { _M_t.swap(__x._M_t); }
-# 460 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      template<typename... _Args>
- std::pair<iterator, bool>
- emplace(_Args&&... __args)
- { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
-# 486 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      template<typename... _Args>
- iterator
- emplace_hint(const_iterator __pos, _Args&&... __args)
- {
-   return _M_t._M_emplace_hint_unique(__pos,
-          std::forward<_Args>(__args)...);
- }
-# 508 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      std::pair<iterator, bool>
-      insert(const value_type& __x)
-      {
- std::pair<typename _Rep_type::iterator, bool> __p =
-   _M_t._M_insert_unique(__x);
- return std::pair<iterator, bool>(__p.first, __p.second);
-      }
-
-
-      std::pair<iterator, bool>
-      insert(value_type&& __x)
-      {
- std::pair<typename _Rep_type::iterator, bool> __p =
-   _M_t._M_insert_unique(std::move(__x));
- return std::pair<iterator, bool>(__p.first, __p.second);
-      }
-# 545 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      iterator
-      insert(const_iterator __position, const value_type& __x)
-      { return _M_t._M_insert_unique_(__position, __x); }
-
-
-      iterator
-      insert(const_iterator __position, value_type&& __x)
-      { return _M_t._M_insert_unique_(__position, std::move(__x)); }
-# 564 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      template<typename _InputIterator>
- void
- insert(_InputIterator __first, _InputIterator __last)
- { _M_t._M_insert_unique(__first, __last); }
-# 577 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      void
-      insert(initializer_list<value_type> __l)
-      { this->insert(__l.begin(), __l.end()); }
-# 652 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      __attribute ((__abi_tag__ ("cxx11")))
-      iterator
-      erase(const_iterator __position)
-      { return _M_t.erase(__position); }
-# 683 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      size_type
-      erase(const key_type& __x)
-      { return _M_t.erase(__x); }
-# 704 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      __attribute ((__abi_tag__ ("cxx11")))
-      iterator
-      erase(const_iterator __first, const_iterator __last)
-      { return _M_t.erase(__first, __last); }
-# 732 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      void
-      clear() noexcept
-      { _M_t.clear(); }
-# 747 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      size_type
-      count(const key_type& __x) const
-      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
-
-
-      template<typename _Kt>
- auto
- count(const _Kt& __x) const
- -> decltype(_M_t._M_count_tr(__x))
- { return _M_t._M_count_tr(__x); }
-# 774 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      iterator
-      find(const key_type& __x)
-      { return _M_t.find(__x); }
-
-      const_iterator
-      find(const key_type& __x) const
-      { return _M_t.find(__x); }
-
-
-      template<typename _Kt>
- auto
- find(const _Kt& __x)
- -> decltype(iterator{_M_t._M_find_tr(__x)})
- { return iterator{_M_t._M_find_tr(__x)}; }
-
-      template<typename _Kt>
- auto
- find(const _Kt& __x) const
- -> decltype(const_iterator{_M_t._M_find_tr(__x)})
- { return const_iterator{_M_t._M_find_tr(__x)}; }
-# 809 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      iterator
-      lower_bound(const key_type& __x)
-      { return _M_t.lower_bound(__x); }
-
-      const_iterator
-      lower_bound(const key_type& __x) const
-      { return _M_t.lower_bound(__x); }
-
-
-      template<typename _Kt>
- auto
- lower_bound(const _Kt& __x)
- -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
- { return iterator(_M_t._M_lower_bound_tr(__x)); }
-
-      template<typename _Kt>
- auto
- lower_bound(const _Kt& __x) const
- -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x)))
- { return const_iterator(_M_t._M_lower_bound_tr(__x)); }
-# 839 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      iterator
-      upper_bound(const key_type& __x)
-      { return _M_t.upper_bound(__x); }
-
-      const_iterator
-      upper_bound(const key_type& __x) const
-      { return _M_t.upper_bound(__x); }
-
-
-      template<typename _Kt>
- auto
- upper_bound(const _Kt& __x)
- -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
- { return iterator(_M_t._M_upper_bound_tr(__x)); }
-
-      template<typename _Kt>
- auto
- upper_bound(const _Kt& __x) const
- -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
- { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
-# 878 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-      std::pair<iterator, iterator>
-      equal_range(const key_type& __x)
-      { return _M_t.equal_range(__x); }
-
-      std::pair<const_iterator, const_iterator>
-      equal_range(const key_type& __x) const
-      { return _M_t.equal_range(__x); }
-
-
-      template<typename _Kt>
- auto
- equal_range(const _Kt& __x)
- -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
- { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }
-
-      template<typename _Kt>
- auto
- equal_range(const _Kt& __x) const
- -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
- { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }
-
-
-
-      template<typename _K1, typename _C1, typename _A1>
- friend bool
- operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
-
-      template<typename _K1, typename _C1, typename _A1>
- friend bool
- operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
-    };
-# 956 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator==(const set<_Key, _Compare, _Alloc>& __x,
-        const set<_Key, _Compare, _Alloc>& __y)
-    { return __x._M_t == __y._M_t; }
-# 973 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator<(const set<_Key, _Compare, _Alloc>& __x,
-       const set<_Key, _Compare, _Alloc>& __y)
-    { return __x._M_t < __y._M_t; }
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator!=(const set<_Key, _Compare, _Alloc>& __x,
-        const set<_Key, _Compare, _Alloc>& __y)
-    { return !(__x == __y); }
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator>(const set<_Key, _Compare, _Alloc>& __x,
-       const set<_Key, _Compare, _Alloc>& __y)
-    { return __y < __x; }
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator<=(const set<_Key, _Compare, _Alloc>& __x,
-        const set<_Key, _Compare, _Alloc>& __y)
-    { return !(__y < __x); }
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator>=(const set<_Key, _Compare, _Alloc>& __x,
-        const set<_Key, _Compare, _Alloc>& __y)
-    { return !(__x < __y); }
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline void
-    swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
-    noexcept(noexcept(__x.swap(__y)))
-    { __x.swap(__y); }
-
-
-# 1035 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_set.h" 3
-
-}
-# 62 "../x86_64-pc-linux-gnu/libstdc++-v3/include/set" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 1 3
-# 64 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    class set;
-# 94 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-  template <typename _Key, typename _Compare = std::less<_Key>,
-     typename _Alloc = std::allocator<_Key> >
-    class multiset
-    {
-# 110 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      static_assert(is_same<typename remove_cv<_Key>::type, _Key>::value,
-   "std::multiset must have a non-const, non-volatile value_type");
-
-
-
-
-
-
-    public:
-
-      typedef _Key key_type;
-      typedef _Key value_type;
-      typedef _Compare key_compare;
-      typedef _Compare value_compare;
-      typedef _Alloc allocator_type;
-
-    private:
-
-      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
- rebind<_Key>::other _Key_alloc_type;
-
-      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
-         key_compare, _Key_alloc_type> _Rep_type;
-
-      _Rep_type _M_t;
-
-      typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits;
-
-    public:
-      typedef typename _Alloc_traits::pointer pointer;
-      typedef typename _Alloc_traits::const_pointer const_pointer;
-      typedef typename _Alloc_traits::reference reference;
-      typedef typename _Alloc_traits::const_reference const_reference;
-
-
-
-      typedef typename _Rep_type::const_iterator iterator;
-      typedef typename _Rep_type::const_iterator const_iterator;
-      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
-      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
-      typedef typename _Rep_type::size_type size_type;
-      typedef typename _Rep_type::difference_type difference_type;
-# 164 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      multiset() = default;
-
-
-
-
-
-
-
-      explicit
-      multiset(const _Compare& __comp,
-        const allocator_type& __a = allocator_type())
-      : _M_t(__comp, _Key_alloc_type(__a)) { }
-# 186 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      template<typename _InputIterator>
- multiset(_InputIterator __first, _InputIterator __last)
- : _M_t()
- { _M_t._M_insert_equal(__first, __last); }
-# 202 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      template<typename _InputIterator>
- multiset(_InputIterator __first, _InputIterator __last,
-   const _Compare& __comp,
-   const allocator_type& __a = allocator_type())
- : _M_t(__comp, _Key_alloc_type(__a))
- { _M_t._M_insert_equal(__first, __last); }
-# 218 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      multiset(const multiset&) = default;
-# 227 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      multiset(multiset&&) = default;
-# 239 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      multiset(initializer_list<value_type> __l,
-        const _Compare& __comp = _Compare(),
-        const allocator_type& __a = allocator_type())
-      : _M_t(__comp, _Key_alloc_type(__a))
-      { _M_t._M_insert_equal(__l.begin(), __l.end()); }
-
-
-      explicit
-      multiset(const allocator_type& __a)
-      : _M_t(_Compare(), _Key_alloc_type(__a)) { }
-
-
-      multiset(const multiset& __m, const allocator_type& __a)
-      : _M_t(__m._M_t, _Key_alloc_type(__a)) { }
-
-
-      multiset(multiset&& __m, const allocator_type& __a)
-      noexcept(is_nothrow_copy_constructible<_Compare>::value
-        && _Alloc_traits::_S_always_equal())
-      : _M_t(std::move(__m._M_t), _Key_alloc_type(__a)) { }
-
-
-      multiset(initializer_list<value_type> __l, const allocator_type& __a)
-      : _M_t(_Compare(), _Key_alloc_type(__a))
-      { _M_t._M_insert_equal(__l.begin(), __l.end()); }
-
-
-      template<typename _InputIterator>
- multiset(_InputIterator __first, _InputIterator __last,
-   const allocator_type& __a)
- : _M_t(_Compare(), _Key_alloc_type(__a))
- { _M_t._M_insert_equal(__first, __last); }
-
-
-
-
-
-
-      ~multiset() = default;
-# 293 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      multiset&
-      operator=(const multiset&) = default;
-
-
-      multiset&
-      operator=(multiset&&) = default;
-# 311 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      multiset&
-      operator=(initializer_list<value_type> __l)
-      {
- _M_t._M_assign_equal(__l.begin(), __l.end());
- return *this;
-      }
-
-
-
-
-
-      key_compare
-      key_comp() const
-      { return _M_t.key_comp(); }
-
-      value_compare
-      value_comp() const
-      { return _M_t.key_comp(); }
-
-      allocator_type
-      get_allocator() const noexcept
-      { return allocator_type(_M_t.get_allocator()); }
-
-
-
-
-
-
-      iterator
-      begin() const noexcept
-      { return _M_t.begin(); }
-
-
-
-
-
-
-      iterator
-      end() const noexcept
-      { return _M_t.end(); }
-
-
-
-
-
-
-      reverse_iterator
-      rbegin() const noexcept
-      { return _M_t.rbegin(); }
-
-
-
-
-
-
-      reverse_iterator
-      rend() const noexcept
-      { return _M_t.rend(); }
-
-
-
-
-
-
-
-      iterator
-      cbegin() const noexcept
-      { return _M_t.begin(); }
-
-
-
-
-
-
-      iterator
-      cend() const noexcept
-      { return _M_t.end(); }
-
-
-
-
-
-
-      reverse_iterator
-      crbegin() const noexcept
-      { return _M_t.rbegin(); }
-
-
-
-
-
-
-      reverse_iterator
-      crend() const noexcept
-      { return _M_t.rend(); }
-
-
-
-      bool
-      empty() const noexcept
-      { return _M_t.empty(); }
-
-
-      size_type
-      size() const noexcept
-      { return _M_t.size(); }
-
-
-      size_type
-      max_size() const noexcept
-      { return _M_t.max_size(); }
-# 436 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      void
-      swap(multiset& __x)
-      noexcept(__is_nothrow_swappable<_Compare>::value)
-      { _M_t.swap(__x._M_t); }
-# 455 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      template<typename... _Args>
- iterator
- emplace(_Args&&... __args)
- { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
-# 481 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      template<typename... _Args>
- iterator
- emplace_hint(const_iterator __pos, _Args&&... __args)
- {
-   return _M_t._M_emplace_hint_equal(__pos,
-         std::forward<_Args>(__args)...);
- }
-# 501 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      iterator
-      insert(const value_type& __x)
-      { return _M_t._M_insert_equal(__x); }
-
-
-      iterator
-      insert(value_type&& __x)
-      { return _M_t._M_insert_equal(std::move(__x)); }
-# 531 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      iterator
-      insert(const_iterator __position, const value_type& __x)
-      { return _M_t._M_insert_equal_(__position, __x); }
-
-
-      iterator
-      insert(const_iterator __position, value_type&& __x)
-      { return _M_t._M_insert_equal_(__position, std::move(__x)); }
-# 549 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      template<typename _InputIterator>
- void
- insert(_InputIterator __first, _InputIterator __last)
- { _M_t._M_insert_equal(__first, __last); }
-# 562 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      void
-      insert(initializer_list<value_type> __l)
-      { this->insert(__l.begin(), __l.end()); }
-# 637 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      __attribute ((__abi_tag__ ("cxx11")))
-      iterator
-      erase(const_iterator __position)
-      { return _M_t.erase(__position); }
-# 668 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      size_type
-      erase(const key_type& __x)
-      { return _M_t.erase(__x); }
-# 689 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      __attribute ((__abi_tag__ ("cxx11")))
-      iterator
-      erase(const_iterator __first, const_iterator __last)
-      { return _M_t.erase(__first, __last); }
-# 717 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      void
-      clear() noexcept
-      { _M_t.clear(); }
-# 729 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      size_type
-      count(const key_type& __x) const
-      { return _M_t.count(__x); }
-
-
-      template<typename _Kt>
- auto
- count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x))
- { return _M_t._M_count_tr(__x); }
-# 755 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      iterator
-      find(const key_type& __x)
-      { return _M_t.find(__x); }
-
-      const_iterator
-      find(const key_type& __x) const
-      { return _M_t.find(__x); }
-
-
-      template<typename _Kt>
- auto
- find(const _Kt& __x)
- -> decltype(iterator{_M_t._M_find_tr(__x)})
- { return iterator{_M_t._M_find_tr(__x)}; }
-
-      template<typename _Kt>
- auto
- find(const _Kt& __x) const
- -> decltype(const_iterator{_M_t._M_find_tr(__x)})
- { return const_iterator{_M_t._M_find_tr(__x)}; }
-# 790 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      iterator
-      lower_bound(const key_type& __x)
-      { return _M_t.lower_bound(__x); }
-
-      const_iterator
-      lower_bound(const key_type& __x) const
-      { return _M_t.lower_bound(__x); }
-
-
-      template<typename _Kt>
- auto
- lower_bound(const _Kt& __x)
- -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
- { return iterator(_M_t._M_lower_bound_tr(__x)); }
-
-      template<typename _Kt>
- auto
- lower_bound(const _Kt& __x) const
- -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
- { return iterator(_M_t._M_lower_bound_tr(__x)); }
-# 820 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      iterator
-      upper_bound(const key_type& __x)
-      { return _M_t.upper_bound(__x); }
-
-      const_iterator
-      upper_bound(const key_type& __x) const
-      { return _M_t.upper_bound(__x); }
-
-
-      template<typename _Kt>
- auto
- upper_bound(const _Kt& __x)
- -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
- { return iterator(_M_t._M_upper_bound_tr(__x)); }
-
-      template<typename _Kt>
- auto
- upper_bound(const _Kt& __x) const
- -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
- { return iterator(_M_t._M_upper_bound_tr(__x)); }
-# 859 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-      std::pair<iterator, iterator>
-      equal_range(const key_type& __x)
-      { return _M_t.equal_range(__x); }
-
-      std::pair<const_iterator, const_iterator>
-      equal_range(const key_type& __x) const
-      { return _M_t.equal_range(__x); }
-
-
-      template<typename _Kt>
- auto
- equal_range(const _Kt& __x)
- -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
- { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }
-
-      template<typename _Kt>
- auto
- equal_range(const _Kt& __x) const
- -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
- { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }
-
-
-
-      template<typename _K1, typename _C1, typename _A1>
- friend bool
- operator==(const multiset<_K1, _C1, _A1>&,
-     const multiset<_K1, _C1, _A1>&);
-
-      template<typename _K1, typename _C1, typename _A1>
- friend bool
- operator< (const multiset<_K1, _C1, _A1>&,
-     const multiset<_K1, _C1, _A1>&);
-    };
-# 941 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator==(const multiset<_Key, _Compare, _Alloc>& __x,
-        const multiset<_Key, _Compare, _Alloc>& __y)
-    { return __x._M_t == __y._M_t; }
-# 958 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator<(const multiset<_Key, _Compare, _Alloc>& __x,
-       const multiset<_Key, _Compare, _Alloc>& __y)
-    { return __x._M_t < __y._M_t; }
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
-        const multiset<_Key, _Compare, _Alloc>& __y)
-    { return !(__x == __y); }
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator>(const multiset<_Key,_Compare,_Alloc>& __x,
-       const multiset<_Key,_Compare,_Alloc>& __y)
-    { return __y < __x; }
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
-        const multiset<_Key, _Compare, _Alloc>& __y)
-    { return !(__y < __x); }
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline bool
-    operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
-        const multiset<_Key, _Compare, _Alloc>& __y)
-    { return !(__x < __y); }
-
-
-  template<typename _Key, typename _Compare, typename _Alloc>
-    inline void
-    swap(multiset<_Key, _Compare, _Alloc>& __x,
-  multiset<_Key, _Compare, _Alloc>& __y)
-    noexcept(noexcept(__x.swap(__y)))
-    { __x.swap(__y); }
-
-
-# 1023 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/stl_multiset.h" 3
-
-}
-# 63 "../x86_64-pc-linux-gnu/libstdc++-v3/include/set" 2 3
-# 1 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/range_access.h" 1 3
-# 33 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/range_access.h" 3
-       
-# 34 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/range_access.h" 3
-
-
-
-namespace std __attribute__ ((__visibility__ ("default")))
-{
-
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    begin(_Container& __cont) -> decltype(__cont.begin())
-    { return __cont.begin(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    begin(const _Container& __cont) -> decltype(__cont.begin())
-    { return __cont.begin(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    end(_Container& __cont) -> decltype(__cont.end())
-    { return __cont.end(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    end(const _Container& __cont) -> decltype(__cont.end())
-    { return __cont.end(); }
-
-
-
-
-
-  template<typename _Tp, size_t _Nm>
-    inline constexpr _Tp*
-    begin(_Tp (&__arr)[_Nm])
-    { return __arr; }
-
-
-
-
-
-
-  template<typename _Tp, size_t _Nm>
-    inline constexpr _Tp*
-    end(_Tp (&__arr)[_Nm])
-    { return __arr + _Nm; }
-
-
-
-  template<typename _Tp> class valarray;
-
-  template<typename _Tp> _Tp* begin(valarray<_Tp>&);
-  template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
-  template<typename _Tp> _Tp* end(valarray<_Tp>&);
-  template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
-
-
-
-
-
-
-  template<typename _Container>
-    inline constexpr auto
-    cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
-      -> decltype(std::begin(__cont))
-    { return std::begin(__cont); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline constexpr auto
-    cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
-      -> decltype(std::end(__cont))
-    { return std::end(__cont); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    rbegin(_Container& __cont) -> decltype(__cont.rbegin())
-    { return __cont.rbegin(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
-    { return __cont.rbegin(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    rend(_Container& __cont) -> decltype(__cont.rend())
-    { return __cont.rend(); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    rend(const _Container& __cont) -> decltype(__cont.rend())
-    { return __cont.rend(); }
-
-
-
-
-
-
-  template<typename _Tp, size_t _Nm>
-    inline reverse_iterator<_Tp*>
-    rbegin(_Tp (&__arr)[_Nm])
-    { return reverse_iterator<_Tp*>(__arr + _Nm); }
-
-
-
-
-
-
-  template<typename _Tp, size_t _Nm>
-    inline reverse_iterator<_Tp*>
-    rend(_Tp (&__arr)[_Nm])
-    { return reverse_iterator<_Tp*>(__arr); }
-
-
-
-
-
-
-  template<typename _Tp>
-    inline reverse_iterator<const _Tp*>
-    rbegin(initializer_list<_Tp> __il)
-    { return reverse_iterator<const _Tp*>(__il.end()); }
-
-
-
-
-
-
-  template<typename _Tp>
-    inline reverse_iterator<const _Tp*>
-    rend(initializer_list<_Tp> __il)
-    { return reverse_iterator<const _Tp*>(__il.begin()); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
-    { return std::rbegin(__cont); }
-
-
-
-
-
-
-  template<typename _Container>
-    inline auto
-    crend(const _Container& __cont) -> decltype(std::rend(__cont))
-    { return std::rend(__cont); }
-# 323 "../x86_64-pc-linux-gnu/libstdc++-v3/include/bits/range_access.h" 3
-
-}
-# 64 "../x86_64-pc-linux-gnu/libstdc++-v3/include/set" 2 3
-# 10 "/tmp/test.C" 2
-
-
-# 11 "/tmp/test.C"
-int main(){
- std::set<int> bar;
- return 0;
-}
+int main() { _Rb_tree_key_compare<int> bar; }
-- 
1.8.5.3

